Merge pull request #4116 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

CMakeLists.txt

@@ -192,8 +192,7 @@ 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).")
 
-# NOTE: We do not currently support building the swift compiler modules with the Xcode generator.
-cmake_dependent_option(BOOTSTRAPPING_MODE [=[
+option(BOOTSTRAPPING_MODE [=[
 How to build the swift compiler modules. Possible values are
     OFF:           build without swift modules
     HOSTTOOLS:     build with a pre-installed toolchain
@@ -204,7 +203,7 @@ How to build the swift compiler modules. Possible values are
                    `SWIFT_NATIVE_SWIFT_TOOLS_PATH` (non-Darwin only)
     CROSSCOMPILE-WITH-HOSTLIBS:    build with a bootstrapping-with-hostlibs compiled
                                    compiler, provided in `SWIFT_NATIVE_SWIFT_TOOLS_PATH`
-]=]  OFF "NOT XCODE" OFF)
+]=] OFF)
 
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
@@ -1115,8 +1114,6 @@ if(SWIFT_INCLUDE_TOOLS)
   # SwiftCompilerSources must come before "tools".
   # It adds swift module names to the global property "swift_compiler_modules"
   # which is used in add_swift_host_tool for the lldb workaround.
-  #
-  # NOTE: We do not currently support SwiftCompilerSources with the Xcode generator.
   add_subdirectory(SwiftCompilerSources)
 
   # Always include this after including stdlib/!

SwiftCompilerSources/CMakeLists.txt

@@ -89,8 +89,7 @@ function(add_swift_compiler_modules_library name)
   set(sdk_option "")
 
   if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
-    set(deployment_version "10.15") # TODO: once #38675 lands, replace this with
-#   set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
+    set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
     set(sdk_option "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
     if(${BOOTSTRAPPING_MODE} STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
       # Let the cross-compiled compile don't pick up the compiled stdlib by providing
@@ -158,6 +157,15 @@ function(add_swift_compiler_modules_library name)
   add_dependencies(${name} ${all_module_targets})
   set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
   set_property(GLOBAL APPEND PROPERTY SWIFT_BUILDTREE_EXPORTS ${name})
+
+  # Xcode does not compile libraries that contain only object files.
+  # Therefore, it fails to create the static library. As a workaround,
+  # we add a dummy script phase to the target.
+  if (XCODE)
+    add_custom_command(TARGET ${name} POST_BUILD 
+      COMMAND ""
+      COMMENT "Dummy script phase to force building this target")
+  endif()
 endfunction()
 
 

docs/DifferentiableProgrammingImplementation.md

@@ -34,7 +34,7 @@ This document explains how differentiation is implemented in the Swift compiler,
 
 ```swift
 // From the standard library:
-// func gradient<T, R>(at x: T, in f: @differentiable (T) -> R) -> T.TangentVector
+// func gradient<T, R>(at x: T, of f: @differentiable (T) -> R) -> T.TangentVector
 // where R: FloatingPoint, R.TangentVector == R
 
 // 1. What does the `@differentiable` attribute do?
@@ -51,7 +51,7 @@ func cubed(_ x: Float) -> Float {
 // transform generates derivative functions for the closure expression. The
 // `gradient` higher-order function extracts and applies a derivative function to
 // evaluate a gradient value.
-gradient(at: 4, in: { x in x * x * x }) // 48.0
+gradient(at: 4, of: { x in x * x * x }) // 48.0
 ```
 
 > NOTE:
@@ -397,13 +397,13 @@ func cubed(_ x: Float) -> Float {
 //   %cubed = differentiable_function [wrt 0] %closure_ref
 //       with {%closure_jvp_ref, %closure_vjp_ref}
 
-gradient(at: Float(4), in: { x in x * x * x })
+gradient(at: Float(4), of: { x in x * x * x })
 
 // Swift supports implicit function conversions, which happens above.
 // Below is what the conversion looks like explicitly:
 // let foo: (Float) -> Float = { x in x * x * x }
 // let cubed: @differentiable (Float) -> Float = foo
-// gradient(at: Float(4), in: cubed)
+// gradient(at: Float(4), of: cubed)
 ```
 
 > TODO: Update the \[differentiable\] attribute directly above the Swift declaration of `cubed(_:)` with a SIL differentiability witness.

lib/IRGen/GenClangDecl.cpp

@@ -40,6 +40,7 @@ class ClangDeclFinder
         isa<clang::VarDecl>(DRE->getDecl())) {
       callback(DRE->getDecl());
     }
+
     return true;
   }
 
@@ -56,6 +57,17 @@ class ClangDeclFinder
     callback(CXXCE->getConstructor());
     return true;
   }
+
+  bool VisitVarDecl(clang::VarDecl *VD) {
+    if (auto cxxRecord = VD->getType()->getAsCXXRecordDecl())
+      if (auto dtor = cxxRecord->getDestructor())
+        callback(dtor);
+
+    return true;
+  }
+
+  bool shouldVisitTemplateInstantiations() const { return true; }
+  bool shouldVisitImplicitCode() const { return true; }
 };
 
 // If any (re)declaration of `decl` contains executable code, returns that
@@ -65,6 +77,11 @@ class ClangDeclFinder
 // the initializer of the variable.
 clang::Decl *getDeclWithExecutableCode(clang::Decl *decl) {
   if (auto fd = dyn_cast<clang::FunctionDecl>(decl)) {
+    // If this is a potentially not-yet-instanciated template, we might
+    // still have a body.
+    if (fd->getTemplateInstantiationPattern())
+      return fd;
+
     const clang::FunctionDecl *definition;
     if (fd->hasBody(definition)) {
       return const_cast<clang::FunctionDecl *>(definition);
@@ -100,7 +117,7 @@ void IRGenModule::emitClangDecl(const clang::Decl *decl) {
   SmallVector<const clang::Decl *, 8> stack;
   stack.push_back(decl);
 
-  ClangDeclFinder refFinder([&](const clang::Decl *D) {
+  auto callback = [&](const clang::Decl *D) {
     for (auto *DC = D->getDeclContext();; DC = DC->getParent()) {
       // Check that this is not a local declaration inside a function.
       if (DC->isFunctionOrMethod()) {
@@ -117,31 +134,55 @@ void IRGenModule::emitClangDecl(const clang::Decl *decl) {
     if (!GlobalClangDecls.insert(D->getCanonicalDecl()).second) {
       return;
     }
+
     stack.push_back(D);
-  });
+  };
+
+  ClangDeclFinder refFinder(callback);
 
   while (!stack.empty()) {
     auto *next = const_cast<clang::Decl *>(stack.pop_back_val());
+
+    // If a function calls another method in a class template specialization, we
+    // need to instantiate that other function. Do that here.
+    if (auto *fn = dyn_cast<clang::FunctionDecl>(next)) {
+      // Make sure that this method is part of a class template specialization.
+      if (fn->getTemplateInstantiationPattern())
+        Context.getClangModuleLoader()
+            ->getClangSema()
+            .InstantiateFunctionDefinition(fn->getLocation(), fn);
+    }
+
     if (clang::Decl *executableDecl = getDeclWithExecutableCode(next)) {
         refFinder.TraverseDecl(executableDecl);
         next = executableDecl;
     }
 
+    // Unfortunately, implicitly defined CXXDestructorDecls don't have a real
+    // body, so we need to traverse these manually.
+    if (auto *dtor = dyn_cast<clang::CXXDestructorDecl>(next)) {
+      auto cxxRecord = dtor->getParent();
+
+      for (auto field : cxxRecord->fields()) {
+        if (auto fieldCxxRecord = field->getType()->getAsCXXRecordDecl())
+          if (auto *fieldDtor = fieldCxxRecord->getDestructor())
+            callback(fieldDtor);
+      }
+
+      for (auto base : cxxRecord->bases()) {
+        if (auto baseCxxRecord = base.getType()->getAsCXXRecordDecl())
+          if (auto *baseDtor = baseCxxRecord->getDestructor())
+            callback(baseDtor);
+      }
+    }
+
     if (auto var = dyn_cast<clang::VarDecl>(next))
       if (!var->isFileVarDecl())
         continue;
     if (isa<clang::FieldDecl>(next)) {
       continue;
     }
-    // If a method calls another method in a class template specialization, we
-    // need to instantiate that other method. Do that here.
-    if (auto *method = dyn_cast<clang::CXXMethodDecl>(next)) {
-      // Make sure that this method is part of a class template specialization.
-      if (method->getTemplateInstantiationPattern())
-        Context.getClangModuleLoader()
-            ->getClangSema()
-            .InstantiateFunctionDefinition(method->getLocation(), method);
-    }
+
     ClangCodeGen->HandleTopLevelDecl(clang::DeclGroupRef(next));
   }
 }

lib/IRGen/GenDecl.cpp

@@ -468,6 +468,10 @@ void IRGenModule::emitSourceFile(SourceFile &SF) {
 
   if (ObjCInterop)
     this->addLinkLibrary(LinkLibrary("objc", LibraryKind::Library));
+
+  // Automatically with libc++ when possible.
+  if (Context.LangOpts.EnableCXXInterop && Context.LangOpts.Target.isOSDarwin())
+    this->addLinkLibrary(LinkLibrary("c++", LibraryKind::Library));
 
   // FIXME: It'd be better to have the driver invocation or build system that
   // executes the linker introduce these compatibility libraries, since at

lib/IRGen/GenStruct.cpp

@@ -81,12 +81,7 @@ static clang::CXXDestructorDecl *getCXXDestructor(SILType type) {
       dyn_cast<clang::CXXRecordDecl>(structDecl->getClangDecl());
   if (!cxxRecordDecl)
     return nullptr;
-  for (auto member : cxxRecordDecl->methods()) {
-    if (auto dest = dyn_cast<clang::CXXDestructorDecl>(member)) {
-      return dest;
-    }
-  }
-  return nullptr;
+  return cxxRecordDecl->getDestructor();
 }
 
 namespace {

lib/SILOptimizer/Mandatory/PredictableMemOpt.cpp

@@ -2888,6 +2888,9 @@ bool swift::optimizeMemoryAccesses(SILFunction &fn) {
 }
 
 bool swift::eliminateDeadAllocations(SILFunction &fn) {
+  if (!fn.hasOwnership())
+    return false;
+
   bool changed = false;
   DeadEndBlocks deadEndBlocks(&fn);
 

lib/SILOptimizer/Transforms/GenericSpecializer.cpp

@@ -253,6 +253,12 @@ optimizeInst(SILInstruction *inst, SILOptFunctionBuilder &funcBuilder,
     if (!callee || callee->isTransparent() == IsNotTransparent)
       return true;
 
+    if (callee->isExternalDeclaration())
+      getModule()->loadFunction(callee);
+
+    if (callee->isExternalDeclaration())
+      return true;
+
     // If the de-virtualized callee is a transparent function, inline it.
     SILInliner::inlineFullApply(newFAS, SILInliner::InlineKind::MandatoryInline,
                                 funcBuilder, deleter);

test/Interop/Cxx/operators/member-out-of-line-silgen.swift

@@ -1,14 +1,17 @@
-// RUN: %target-swift-emit-sil %s -I %S/Inputs -enable-cxx-interop | %FileCheck %s
-//
-// We can't yet call member functions correctly on Windows (SR-13129).
-// XFAIL: OS=windows-msvc
+// RUN: %target-swift-emit-sil %s -I %S/Inputs -enable-cxx-interop | %FileCheck %s -check-prefix CHECK-%target-abi
 
 import MemberOutOfLine
 
 public func add(_ lhs: LoadableIntWrapper, _ rhs: LoadableIntWrapper) -> LoadableIntWrapper { lhs + rhs }
 
-// CHECK: bb0([[LHS:%.*]] : $LoadableIntWrapper, [[RHS:%.*]] : $LoadableIntWrapper):
-// CHECK:   [[FUNC:%.*]] = function_ref [[NAME:@_ZNK18LoadableIntWrapperplES_]] : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
-// CHECK:   apply [[FUNC]]([[ACCESS:%.*]], [[RHS]]) : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
+// CHECK-SYSV: bb0([[LHS:%.*]] : $LoadableIntWrapper, [[RHS:%.*]] : $LoadableIntWrapper):
+// CHECK-SYSV:   [[FUNC:%.*]] = function_ref [[NAME:@_ZNK18LoadableIntWrapperplES_]] : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
+// CHECK-SYSV:   apply [[FUNC]]([[ACCESS:%.*]], [[RHS]]) : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
 
-// CHECK: sil [clang LoadableIntWrapper."+"] [[NAME]] : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
+// CHECK-SYSV: sil [clang LoadableIntWrapper."+"] [[NAME]] : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
+
+// CHECK-WIN: bb0([[LHS:%.*]] : $LoadableIntWrapper, [[RHS:%.*]] : $LoadableIntWrapper):
+// CHECK-WIN:   [[FUNC:%.*]] = function_ref [[NAME:@\?\?HLoadableIntWrapper@@QEBA\?AU0@U0@@Z]] : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
+// CHECK-WIN:   apply [[FUNC]]([[ACCESS:%.*]], [[RHS]]) : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper
+
+// CHECK-WIN: sil [clang LoadableIntWrapper."+"] [[NAME]] : $@convention(c) (@in LoadableIntWrapper, LoadableIntWrapper) -> LoadableIntWrapper

test/Interop/Cxx/stdlib/Inputs/module.modulemap

@@ -0,0 +1,3 @@
+module StdVector {
+  header "std-vector.h"
+}