Merge pull request #3437 from swiftwasm/release/5.5

pull[bot] · web-flow · commit cfb065d74708 · 2021-08-31T10:11:03.000Z
[pull] swiftwasm-release/5.5 from release/5.5
diff --git a/include/swift/AST/Module.h b/include/swift/AST/Module.h
@@ -645,9 +645,10 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// This assumes that \p module was imported.
   bool isImportedImplementationOnly(const ModuleDecl *module) const;
 
-  /// Returns true if a function, which is using \p nominal, can be serialized
-  /// by cross-module-optimization.
-  bool canBeUsedForCrossModuleOptimization(NominalTypeDecl *nominal) const;
+  /// Returns true if decl context or its content can be serialized by
+  /// cross-module-optimization.
+  /// The \p ctxt can e.g. be a NominalType or the context of a function.
+  bool canBeUsedForCrossModuleOptimization(DeclContext *ctxt) const;
 
   /// Finds all top-level decls of this module.
   ///
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -2179,14 +2179,15 @@ bool ModuleDecl::isImportedImplementationOnly(const ModuleDecl *module) const {
 }
 
 bool ModuleDecl::
-canBeUsedForCrossModuleOptimization(NominalTypeDecl *nominal) const {
-  ModuleDecl *moduleOfNominal = nominal->getParentModule();
+canBeUsedForCrossModuleOptimization(DeclContext *ctxt) const {
+  ModuleDecl *moduleOfCtxt = ctxt->getParentModule();
 
-  // If the nominal is defined in the same module, it's fine.
-  if (moduleOfNominal == this)
+  // If the context defined in the same module - or is the same module, it's
+  // fine.
+  if (moduleOfCtxt == this)
     return true;
 
-  // See if nominal is imported in a "regular" way, i.e. not with
+  // See if context is imported in a "regular" way, i.e. not with
   // @_implementationOnly or @_spi.
   ModuleDecl::ImportFilter filter = {
     ModuleDecl::ImportFilterKind::Exported,
@@ -2196,7 +2197,7 @@ canBeUsedForCrossModuleOptimization(NominalTypeDecl *nominal) const {
 
   auto &imports = getASTContext().getImportCache();
   for (auto &desc : results) {
-    if (imports.isImportedBy(moduleOfNominal, desc.importedModule))
+    if (imports.isImportedBy(moduleOfCtxt, desc.importedModule))
       return true;
   }
   return false;
diff --git a/lib/SILOptimizer/IPO/ClosureSpecializer.cpp b/lib/SILOptimizer/IPO/ClosureSpecializer.cpp
@@ -57,6 +57,7 @@
 
 #define DEBUG_TYPE "closure-specialization"
 #include "swift/Basic/Range.h"
+#include "swift/Demangling/Demangler.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILCloner.h"
 #include "swift/SIL/SILFunction.h"
@@ -162,6 +163,14 @@ class ClosureSpecCloner : public SILClonerWithScopes<ClosureSpecCloner> {
 namespace {
 struct ClosureInfo;
 
+static SILFunction *getClosureCallee(SILInstruction *inst) {
+  if (auto *PAI = dyn_cast<PartialApplyInst>(inst))
+    return cast<FunctionRefInst>(PAI->getCallee())->getReferencedFunction();
+
+  auto *TTTFI = cast<ThinToThickFunctionInst>(inst);
+  return cast<FunctionRefInst>(TTTFI->getCallee())->getReferencedFunction();
+}
+
 class CallSiteDescriptor {
   ClosureInfo *CInfo;
   FullApplySite AI;
@@ -188,11 +197,7 @@ class CallSiteDescriptor {
   }
 
   SILFunction *getClosureCallee() const {
-    if (auto *PAI = dyn_cast<PartialApplyInst>(getClosure()))
-      return cast<FunctionRefInst>(PAI->getCallee())->getReferencedFunction();
-
-    auto *TTTFI = cast<ThinToThickFunctionInst>(getClosure());
-    return cast<FunctionRefInst>(TTTFI->getCallee())->getReferencedFunction();
+    return ::getClosureCallee(getClosure());
   }
 
   bool closureHasRefSemanticContext() const {
@@ -1065,6 +1070,59 @@ static bool canSpecializeFullApplySite(FullApplySiteKind kind) {
   llvm_unreachable("covered switch");
 }
 
+static int getSpecializationLevelRecursive(StringRef funcName, Demangler &parent) {
+  using namespace Demangle;
+
+  Demangler demangler;
+  demangler.providePreallocatedMemory(parent);
+
+  // Check for this kind of node tree:
+  //
+  // kind=Global
+  //   kind=FunctionSignatureSpecialization
+  //     kind=SpecializationPassID, index=1
+  //     kind=FunctionSignatureSpecializationParam
+  //       kind=FunctionSignatureSpecializationParamKind, index=5
+  //       kind=FunctionSignatureSpecializationParamPayload, text="..."
+  //
+  Node *root = demangler.demangleSymbol(funcName);
+  if (!root)
+    return 0;
+  if (root->getKind() != Node::Kind::Global)
+    return 0;
+  Node *funcSpec = root->getFirstChild();
+  if (!funcSpec || funcSpec->getNumChildren() < 2)
+    return 0;
+  if (funcSpec->getKind() != Node::Kind::FunctionSignatureSpecialization)
+    return 0;
+  Node *param = funcSpec->getChild(1);
+  if (param->getKind() != Node::Kind::FunctionSignatureSpecializationParam)
+    return 0;
+  if (param->getNumChildren() < 2)
+    return 0;
+  Node *kindNd = param->getChild(0);
+  if (kindNd->getKind() != Node::Kind::FunctionSignatureSpecializationParamKind)
+    return 0;
+  auto kind = FunctionSigSpecializationParamKind(kindNd->getIndex());
+  if (kind != FunctionSigSpecializationParamKind::ConstantPropFunction)
+    return 0;
+    
+  Node *payload = param->getChild(1);
+  if (payload->getKind() != Node::Kind::FunctionSignatureSpecializationParamPayload)
+    return 1;
+  // Check if the specialized function is a specialization itself.
+  return 1 + getSpecializationLevelRecursive(payload->getText(), demangler);
+}
+
+/// If \p function is a function-signature specialization for a constant-
+/// propagated function argument, returns 1.
+/// If \p function is a specialization of such a specialization, returns 2.
+/// And so on.
+static int getSpecializationLevel(SILFunction *f) {
+  Demangle::StackAllocatedDemangler<1024> demangler;
+  return getSpecializationLevelRecursive(f->getName(), demangler);
+}
+
 bool SILClosureSpecializerTransform::gatherCallSites(
     SILFunction *Caller,
     llvm::SmallVectorImpl<std::unique_ptr<ClosureInfo>> &ClosureCandidates,
@@ -1252,6 +1310,24 @@ bool SILClosureSpecializerTransform::gatherCallSites(
           continue;
         }
 
+        // Avoid an infinite specialization loop caused by repeated runs of
+        // ClosureSpecializer and CapturePropagation.
+        // CapturePropagation propagates constant function-literals. Such
+        // function specializations can then be optimized again by the
+        // ClosureSpecializer and so on.
+        // This happens if a closure argument is called _and_ referenced in
+        // another closure, which is passed to a recursive call. E.g.
+        //
+        // func foo(_ c: @escaping () -> ()) {
+        //   c()
+        //   foo({ c() })
+        // }
+        //
+        // A limit of 2 is good enough and will not be exceed in "regular"
+        // optimization scenarios.
+        if (getSpecializationLevel(getClosureCallee(ClosureInst)) > 2)
+          continue;
+
         // Compute the final release points of the closure. We will insert
         // release of the captured arguments here.
         if (!CInfo)
diff --git a/lib/SILOptimizer/IPO/CrossModuleSerializationSetup.cpp b/lib/SILOptimizer/IPO/CrossModuleSerializationSetup.cpp
@@ -386,6 +386,11 @@ bool CrossModuleSerializationSetup::canUseFromInline(SILFunction *func,
   if (!func)
     return false;
 
+  if (DeclContext *funcCtxt = func->getDeclContext()) {
+    if (!M.getSwiftModule()->canBeUsedForCrossModuleOptimization(funcCtxt))
+      return false;
+  }
+
   switch (func->getLinkage()) {
   case SILLinkage::PublicNonABI:
     return func->isSerialized() != IsNotSerialized;
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -873,6 +873,25 @@ void TypeChecker::buildTypeRefinementContextHierarchy(SourceFile &SF) {
   }
 }
 
+void TypeChecker::buildTypeRefinementContextHierarchyDelayed(SourceFile &SF, AbstractFunctionDecl *AFD) {
+  // If there's no TRC for the file, we likely don't want this one either.
+  // RootTRC is not set when availability checking is disabled.
+  TypeRefinementContext *RootTRC = SF.getTypeRefinementContext();
+  if(!RootTRC)
+    return;
+
+  if (AFD->getBodyKind() != AbstractFunctionDecl::BodyKind::Unparsed)
+    return;
+
+  // Parse the function body.
+  AFD->getBody(/*canSynthesize=*/true);
+
+  // Build the refinement context for the function body.
+  ASTContext &Context = SF.getASTContext();
+  TypeRefinementContextBuilder Builder(RootTRC, Context);
+  Builder.build(AFD);
+}
+
 TypeRefinementContext *
 TypeChecker::getOrBuildTypeRefinementContext(SourceFile *SF) {
   TypeRefinementContext *TRC = SF->getTypeRefinementContext();
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
@@ -256,6 +256,7 @@ static void typeCheckDelayedFunctions(SourceFile &SF) {
          ++currentFunctionIdx) {
       auto *AFD = SF.DelayedFunctions[currentFunctionIdx];
       assert(!AFD->getDeclContext()->isLocalContext());
+      TypeChecker::buildTypeRefinementContextHierarchyDelayed(SF, AFD);
       (void)AFD->getTypecheckedBody();
     }
 
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -958,6 +958,10 @@ AvailabilityContext overApproximateAvailabilityAtLocation(
 /// Walk the AST to build the hierarchy of TypeRefinementContexts
 void buildTypeRefinementContextHierarchy(SourceFile &SF);
 
+/// Walk the AST to complete the hierarchy of TypeRefinementContexts for
+/// the delayed function body of \p AFD.
+void buildTypeRefinementContextHierarchyDelayed(SourceFile &SF, AbstractFunctionDecl *AFD);
+
 /// Build the hierarchy of TypeRefinementContexts for the entire
 /// source file, if it has not already been built. Returns the root
 /// TypeRefinementContext for the source file.
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -406,7 +406,14 @@ SILFunction *SILDeserializer::getFuncForReference(StringRef name,
   // SIL.
   SourceLoc sourceLoc;
   SILSerializationFunctionBuilder builder(SILMod);
-  return builder.createDeclaration(name, type, RegularLocation(sourceLoc));
+  fn = builder.createDeclaration(name, type,
+                                 RegularLocation(sourceLoc));
+  // The function is not really de-serialized, but it's important to call
+  // `didDeserialize` on every new function. Otherwise some Analysis might miss
+  // `notifyAddedOrModifiedFunction` notifications.
+  if (Callback)
+    Callback->didDeserialize(MF->getAssociatedModule(), fn);
+  return fn;
 }
 
 /// Helper function to find a SILFunction, given its name and type.
diff --git a/test/SILOptimizer/Inputs/cross-module/c-module.c b/test/SILOptimizer/Inputs/cross-module/c-module.c
@@ -0,0 +1,7 @@
+
+#include "c-module.h"
+
+long privateCFunc() {
+  return 123;
+}
+
diff --git a/test/SILOptimizer/Inputs/cross-module/c-module.h b/test/SILOptimizer/Inputs/cross-module/c-module.h
@@ -0,0 +1,3 @@
+
+long privateCFunc();
+
diff --git a/test/SILOptimizer/Inputs/cross-module/cross-module-objc.swift b/test/SILOptimizer/Inputs/cross-module/cross-module-objc.swift
diff --git a/test/SILOptimizer/Inputs/cross-module/cross-module.swift b/test/SILOptimizer/Inputs/cross-module/cross-module.swift
@@ -1,5 +1,6 @@
 import Submodule
 @_implementationOnly import PrivateSubmodule
+@_implementationOnly import PrivateCModule
 
 private enum PE<T> {
   case A
@@ -268,11 +269,19 @@ public func callUnrelated<T>(_ t: T) -> T {
   return t
 }
 
-public func callImplementationOnly<T>(_ t: T) -> T {
+public func callImplementationOnlyType<T>(_ t: T) -> T {
   let p = PrivateStr(i: 27)
   print(p.test())
   return t
 }
 
+public func callImplementationOnlyFunc<T>(_ t: T) -> Int {
+  return privateFunc()
+}
+
+public func callCImplementationOnly<T>(_ t: T) -> Int {
+  return Int(privateCFunc())
+}
+
 
 public let globalLet = 529387
diff --git a/test/SILOptimizer/Inputs/cross-module/cross-private-submodule.swift b/test/SILOptimizer/Inputs/cross-module/cross-private-submodule.swift
@@ -12,3 +12,6 @@ public struct PrivateStr {
   }
 }
 
+public func privateFunc() -> Int {
+  return 40
+}
diff --git a/test/SILOptimizer/Inputs/cross-module/cross-submodule.swift b/test/SILOptimizer/Inputs/cross-module/cross-submodule.swift
diff --git a/test/SILOptimizer/Inputs/cross-module/module.modulemap b/test/SILOptimizer/Inputs/cross-module/module.modulemap
@@ -0,0 +1,3 @@
+module PrivateCModule {
+  header "c-module.h"
+}
diff --git a/test/SILOptimizer/closure_specialize_loop.swift b/test/SILOptimizer/closure_specialize_loop.swift
@@ -0,0 +1,16 @@
+// RUN: %{python} %S/../Inputs/timeout.py 10 %target-swift-frontend -O -parse-as-library %s -emit-sil | %FileCheck %s
+
+public func callit() {
+    testit { false }
+}
+
+// Check if the compiler terminates and does not full into an infinite optimization
+// loop between the ClosureSpecializer and CapturePropagation.
+
+// CHECK-LABEL: sil @$s23closure_specialize_loop6testit1cySbyc_tF
+public func testit(c: @escaping () -> Bool) {
+  if c() {
+    testit { !c() }
+  }
+}
+
diff --git a/test/SILOptimizer/cross-module-optimization-objc.swift b/test/SILOptimizer/cross-module-optimization-objc.swift
@@ -1,7 +1,7 @@
 // First test: functional correctness
 
 // RUN: %empty-directory(%t) 
-// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/Test.swiftmodule -module-name=Test -I%t %S/Inputs/cross-module-objc.swift -c -o %t/test.o
+// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/Test.swiftmodule -module-name=Test -I%t %S/Inputs/cross-module/cross-module-objc.swift -c -o %t/test.o
 // RUN: %target-build-swift -O -wmo -module-name=Main -I%t %s -c -o %t/main.o
 // RUN: %target-swiftc_driver %t/main.o %t/test.o -o %t/a.out
 // RUN: %target-codesign %t/a.out
diff --git a/test/SILOptimizer/cross-module-optimization.swift b/test/SILOptimizer/cross-module-optimization.swift
@@ -1,18 +1,19 @@
 // First test: functional correctness
 
 // RUN: %empty-directory(%t) 
-// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/Submodule.swiftmodule -module-name=Submodule %S/Inputs/cross-submodule.swift -c -o %t/submodule.o
-// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/PrivateSubmodule.swiftmodule -module-name=PrivateSubmodule %S/Inputs/cross-private-submodule.swift -c -o %t/privatesubmodule.o
-// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/Test.swiftmodule -module-name=Test -I%t %S/Inputs/cross-module.swift -c -o %t/test.o
+// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/Submodule.swiftmodule -module-name=Submodule %S/Inputs/cross-module/cross-submodule.swift -c -o %t/submodule.o
+// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/PrivateSubmodule.swiftmodule -module-name=PrivateSubmodule %S/Inputs/cross-module/cross-private-submodule.swift -c -o %t/privatesubmodule.o
+// RUN: %target-clang -c --language=c %S/Inputs/cross-module/c-module.c -o %t/c-module.o
+// RUN: %target-build-swift -O -wmo -parse-as-library -cross-module-optimization -emit-module -emit-module-path=%t/Test.swiftmodule -module-name=Test -I%t -I%S/Inputs/cross-module %S/Inputs/cross-module/cross-module.swift -c -o %t/test.o
 // RUN: %target-build-swift -O -wmo -module-name=Main -I%t %s -c -o %t/main.o
-// RUN: %target-swiftc_driver %t/main.o %t/test.o %t/submodule.o %t/privatesubmodule.o -o %t/a.out
+// RUN: %target-swiftc_driver %t/main.o %t/test.o %t/submodule.o %t/privatesubmodule.o %t/c-module.o -o %t/a.out
 // RUN: %target-codesign %t/a.out
 // RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
 
 // Check if it also works if the main module is compiled with -Onone:
 
 // RUN: %target-build-swift -Onone -wmo -module-name=Main -I%t %s -c -o %t/main-onone.o
-// RUN: %target-swiftc_driver %t/main-onone.o %t/test.o %t/submodule.o %t/privatesubmodule.o -o %t/a.out
+// RUN: %target-swiftc_driver %t/main-onone.o %t/test.o %t/submodule.o %t/privatesubmodule.o %t/c-module.o -o %t/a.out
 // RUN: %target-codesign %t/a.out
 // RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
 
@@ -146,8 +147,14 @@ func testGlobal() {
 @inline(never)
 func testImplementationOnly() {
   // CHECK-OUTPUT: 27
-  // CHECK-SIL2: function_ref @$s4Test22callImplementationOnlyyxxlF
-  print(callImplementationOnly(27))
+  // CHECK-SIL2: function_ref @$s4Test26callImplementationOnlyTypeyxxlF
+  print(callImplementationOnlyType(27))
+  // CHECK-OUTPUT: 40
+  // CHECK-SIL2: function_ref @$s4Test26callImplementationOnlyFuncySixlF
+  print(callImplementationOnlyFunc(0))
+  // CHECK-OUTPUT: 123
+  // CHECK-SIL2: function_ref @$s4Test23callCImplementationOnlyySixlF
+  print(callCImplementationOnly(0))
   // CHECK-SIL2: } // end sil function '$s4Main22testImplementationOnlyyyF'
 }
 
diff --git a/test/Sema/availability_and_delayed_parsing.swift b/test/Sema/availability_and_delayed_parsing.swift

Original file line number	Diff line number	Diff line change
`@@ -256,6 +256,7 @@ static void typeCheckDelayedFunctions(SourceFile &SF) {`
`256`	`256`	`++currentFunctionIdx) {`
`257`	`257`	`auto *AFD = SF.DelayedFunctions[currentFunctionIdx];`
`258`	`258`	`assert(!AFD->getDeclContext()->isLocalContext());`
	`259`	`+ TypeChecker::buildTypeRefinementContextHierarchyDelayed(SF, AFD);`
`259`	`260`	`(void)AFD->getTypecheckedBody();`
`260`	`261`	`}`
`261`	`262`