Merge pull request #2348 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -1158,6 +1158,10 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// Note that if \p RI is a retain-instruction always false is returned.
   bool canEscapeTo(SILValue V, RefCountingInst *RI);
 
+  /// Returns true if the value \p V can escape to the destroy_value instruction
+  /// \p DVI.
+  bool canEscapeTo(SILValue V, DestroyValueInst *DVI);
+
   /// Return true if \p releasedReference deinitialization may release memory
   /// pointed to by \p accessedAddress.
   bool mayReleaseContent(SILValue releasedReference, SILValue accessedAddress);

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -870,6 +870,7 @@ void EscapeAnalysis::ConnectionGraph::computeUsePoints() {
 #include "swift/AST/ReferenceStorage.def"
         case SILInstructionKind::StrongReleaseInst:
         case SILInstructionKind::ReleaseValueInst:
+        case SILInstructionKind::DestroyValueInst:
         case SILInstructionKind::ApplyInst:
         case SILInstructionKind::TryApplyInst: {
           /// Actually we only add instructions which may release a reference.
@@ -2589,8 +2590,9 @@ bool EscapeAnalysis::canEscapeToUsePoint(SILValue value,
                                          SILInstruction *usePoint,
                                          ConnectionGraph *conGraph) {
 
-  assert((FullApplySite::isa(usePoint) || isa<RefCountingInst>(usePoint))
-         && "use points are only created for calls and refcount instructions");
+  assert((FullApplySite::isa(usePoint) || isa<RefCountingInst>(usePoint) ||
+          isa<DestroyValueInst>(usePoint)) &&
+         "use points are only created for calls and refcount instructions");
 
   CGNode *node = conGraph->getValueContent(value);
   if (!node)
@@ -2649,6 +2651,14 @@ bool EscapeAnalysis::canEscapeTo(SILValue V, RefCountingInst *RI) {
   return canEscapeToUsePoint(V, RI, ConGraph);
 }
 
+bool EscapeAnalysis::canEscapeTo(SILValue V, DestroyValueInst *DVI) {
+  // If it's not uniquely identified we don't know anything about the value.
+  if (!isUniquelyIdentified(V))
+    return true;
+  auto *ConGraph = getConnectionGraph(DVI->getFunction());
+  return canEscapeToUsePoint(V, DVI, ConGraph);
+}
+
 /// Utility to get the function which contains both values \p V1 and \p V2.
 static SILFunction *getCommonFunction(SILValue V1, SILValue V2) {
   SILBasicBlock *BB1 = V1->getParentBlock();

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -182,6 +182,7 @@ class MemoryBehaviorVisitor
   MemBehavior visitBuiltinInst(BuiltinInst *BI);
   MemBehavior visitStrongReleaseInst(StrongReleaseInst *BI);
   MemBehavior visitReleaseValueInst(ReleaseValueInst *BI);
+  MemBehavior visitDestroyValueInst(DestroyValueInst *DVI);
   MemBehavior visitSetDeallocatingInst(SetDeallocatingInst *BI);
   MemBehavior visitBeginCOWMutationInst(BeginCOWMutationInst *BCMI);
 #define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
@@ -225,6 +226,7 @@ class MemoryBehaviorVisitor
   }
   REFCOUNTINC_MEMBEHAVIOR_INST(StrongRetainInst)
   REFCOUNTINC_MEMBEHAVIOR_INST(RetainValueInst)
+  REFCOUNTINC_MEMBEHAVIOR_INST(CopyValueInst)
 #define UNCHECKED_REF_STORAGE(Name, ...)                                       \
   REFCOUNTINC_MEMBEHAVIOR_INST(Name##RetainValueInst)                          \
   REFCOUNTINC_MEMBEHAVIOR_INST(StrongCopy##Name##ValueInst)
@@ -490,6 +492,13 @@ MemBehavior MemoryBehaviorVisitor::visitReleaseValueInst(ReleaseValueInst *SI) {
   return MemBehavior::MayHaveSideEffects;
 }
 
+MemBehavior
+MemoryBehaviorVisitor::visitDestroyValueInst(DestroyValueInst *DVI) {
+  if (!EA->canEscapeTo(V, DVI))
+    return MemBehavior::None;
+  return MemBehavior::MayHaveSideEffects;
+}
+
 MemBehavior MemoryBehaviorVisitor::visitSetDeallocatingInst(SetDeallocatingInst *SDI) {
   return MemBehavior::None;
 }

lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp

@@ -292,9 +292,7 @@ std::string ExistentialTransform::createExistentialSpecializedFunctionName() {
     int Idx = IdxIt.first;
     Mangler.setArgumentExistentialToGeneric(Idx);
   }
-  auto MangledName = Mangler.mangle();
-  assert(!F->getModule().hasFunction(MangledName));
-  return MangledName;
+  return Mangler.mangle();
 }
 
 /// Convert all existential argument types to generic argument type.
@@ -642,41 +640,47 @@ void ExistentialTransform::populateThunkBody() {
 ///     its inline strategy as always inline.
 void ExistentialTransform::createExistentialSpecializedFunction() {
   std::string Name = createExistentialSpecializedFunctionName();
-  SILLinkage linkage = getSpecializedLinkage(F, F->getLinkage());
 
-  /// Create devirtualized function type.
+  /// Create devirtualized function type and populate ArgToGenericTypeMap.
   auto NewFTy = createExistentialSpecializedFunctionType();
 
-  auto NewFGenericSig = NewFTy->getInvocationGenericSignature();
-  auto NewFGenericEnv = NewFGenericSig->getGenericEnvironment();
-
   /// Step 1: Create the new protocol constrained generic function.
-  NewF = FunctionBuilder.createFunction(
+  if (auto *CachedFn = F->getModule().lookUpFunction(Name)) {
+    // The specialized body still exists (because it is now called directly),
+    // but the thunk has been dead-code eliminated.
+    assert(CachedFn->getLoweredFunctionType() == NewFTy);
+    NewF = CachedFn;
+  } else {
+    auto NewFGenericSig = NewFTy->getInvocationGenericSignature();
+    auto NewFGenericEnv = NewFGenericSig->getGenericEnvironment();
+    SILLinkage linkage = getSpecializedLinkage(F, F->getLinkage());
+
+    NewF = FunctionBuilder.createFunction(
       linkage, Name, NewFTy, NewFGenericEnv, F->getLocation(), F->isBare(),
       F->isTransparent(), F->isSerialized(), IsNotDynamic, F->getEntryCount(),
       F->isThunk(), F->getClassSubclassScope(), F->getInlineStrategy(),
       F->getEffectsKind(), nullptr, F->getDebugScope());
-  /// Set the semantics attributes for the new function.
-  for (auto &Attr : F->getSemanticsAttrs())
-    NewF->addSemanticsAttr(Attr);
 
-  /// Set Unqualified ownership, if any.
-  if (!F->hasOwnership()) {
-    NewF->setOwnershipEliminated();
-  }
+    /// Set the semantics attributes for the new function.
+    for (auto &Attr : F->getSemanticsAttrs())
+      NewF->addSemanticsAttr(Attr);
 
-  /// Step 1a: Populate the body of NewF.
-  SubstitutionMap Subs = SubstitutionMap::get(
+    /// Set Unqualified ownership, if any.
+    if (!F->hasOwnership()) {
+      NewF->setOwnershipEliminated();
+    }
+    /// Step 1a: Populate the body of NewF.
+    SubstitutionMap Subs = SubstitutionMap::get(
       NewFGenericSig,
       [&](SubstitutableType *type) -> Type {
         return NewFGenericEnv->mapTypeIntoContext(type);
       },
       LookUpConformanceInModule(F->getModule().getSwiftModule()));
-  ExistentialSpecializerCloner cloner(F, NewF, Subs, ArgumentDescList,
-                                      ArgToGenericTypeMap,
-                                      ExistentialArgDescriptor);
-  cloner.cloneAndPopulateFunction();
-
+    ExistentialSpecializerCloner cloner(F, NewF, Subs, ArgumentDescList,
+                                        ArgToGenericTypeMap,
+                                        ExistentialArgDescriptor);
+    cloner.cloneAndPopulateFunction();
+  }
   /// Step 2: Create the thunk with always_inline and populate its body.
   populateThunkBody();
 

lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -146,15 +146,6 @@ static bool inline isPerformingRLE(RLEKind Kind) {
 /// general sense but are inert from a load store perspective.
 static bool isRLEInertInstruction(SILInstruction *Inst) {
   switch (Inst->getKind()) {
-#define UNCHECKED_REF_STORAGE(Name, ...)                                       \
-  case SILInstructionKind::StrongCopy##Name##ValueInst:
-#define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
-  case SILInstructionKind::Name##RetainInst:                                   \
-  case SILInstructionKind::StrongRetain##Name##Inst:                           \
-  case SILInstructionKind::StrongCopy##Name##ValueInst:
-#include "swift/AST/ReferenceStorage.def"
-  case SILInstructionKind::StrongRetainInst:
-  case SILInstructionKind::RetainValueInst:
   case SILInstructionKind::DeallocStackInst:
   case SILInstructionKind::CondFailInst:
   case SILInstructionKind::IsEscapingClosureInst:

lib/SILOptimizer/UtilityPasses/EscapeAnalysisDumper.cpp

@@ -85,6 +85,14 @@ class EscapeAnalysisDumper : public SILModuleTransform {
                              << " to " << ii;
               }
             }
+            if (DestroyValueInst *dvi = dyn_cast<DestroyValueInst>(&ii)) {
+              for (unsigned i = 0, e = Values.size(); i != e; ++i) {
+                SILValue val = Values[i];
+                bool escape = EA->canEscapeTo(val, dvi);
+                llvm::outs() << (escape ? "May" : "No") << "Escape: " << val
+                             << " to " << ii;
+              }
+            }
           }
         }
       }

test/Driver/Dependencies/check-interface-implementation-fine.swift

@@ -14,9 +14,9 @@
 // CHECK-FIRST: Handled c.swift
 // CHECK-FIRST: Handled bad.swift
 
-// CHECK-RECORD-CLEAN-DAG: "./a.swift": [
-// CHECK-RECORD-CLEAN-DAG: "./bad.swift": [
-// CHECK-RECORD-CLEAN-DAG: "./c.swift": [
+// CHECK-RECORD-CLEAN-DAG: "{{(./)?}}a.swift": [
+// CHECK-RECORD-CLEAN-DAG: "{{(./)?}}bad.swift": [
+// CHECK-RECORD-CLEAN-DAG: "{{(./)?}}c.swift": [
 
 
 // RUN: touch -t 201401240006 %t/a.swift
@@ -29,9 +29,9 @@
 // CHECK-A: Handled bad.swift
 // NEGATIVE-A-NOT: Handled c.swift
 
-// CHECK-RECORD-A-DAG: "./a.swift": [
-// CHECK-RECORD-A-DAG: "./bad.swift": !private [
-// CHECK-RECORD-A-DAG: "./c.swift": !private [
+// CHECK-RECORD-A-DAG: "{{(./)?}}a.swift": [
+// CHECK-RECORD-A-DAG: "{{(./)?}}bad.swift": !private [
+// CHECK-RECORD-A-DAG: "{{(./)?}}c.swift": !private [
 
 // RUN: cd %t &&   %swiftc_driver -c -driver-use-frontend-path "%{python.unquoted};%S/Inputs/update-dependencies.py;%swift-dependency-tool" -output-file-map %t/output.json -incremental -driver-always-rebuild-dependents ./a.swift ./bad.swift ./c.swift  -module-name main -j1 -v  -driver-show-incremental 2>&1 | %FileCheck -check-prefix CHECK-BC %s
 

test/Driver/Dependencies/crash-added-fine.swift

@@ -17,9 +17,9 @@
 // CHECK-ADDED: Handled crash.swift
 // CHECK-ADDED-NOT: Handled
 
-// CHECK-RECORD-ADDED-DAG: "./crash.swift": !private [
-// CHECK-RECORD-ADDED-DAG: "./main.swift": [
-// CHECK-RECORD-ADDED-DAG: "./other.swift": [
+// CHECK-RECORD-ADDED-DAG: "{{(./)?}}crash.swift": !private [
+// CHECK-RECORD-ADDED-DAG: "{{(./)?}}main.swift": [
+// CHECK-RECORD-ADDED-DAG: "{{(./)?}}other.swift": [
 
 
 // RUN: %empty-directory(%t)

test/Driver/Dependencies/crash-simple-fine.swift

@@ -20,9 +20,9 @@
 
 // RUN: %FileCheck -check-prefix=CHECK-RECORD %s < %t/main~buildrecord.swiftdeps
 
-// CHECK-RECORD-DAG: "./crash.swift": !private [
-// CHECK-RECORD-DAG: "./main.swift": !private [
-// CHECK-RECORD-DAG: "./other.swift": !private [
+// CHECK-RECORD-DAG: "{{(./)?}}crash.swift": !private [
+// CHECK-RECORD-DAG: "{{(./)?}}main.swift": !private [
+// CHECK-RECORD-DAG: "{{(./)?}}other.swift": !private [
 
 // RUN: cd %t &&  %swiftc_driver -c -driver-use-frontend-path "%{python.unquoted};%S/Inputs/update-dependencies.py;%swift-dependency-tool" -output-file-map %t/output.json -incremental -driver-always-rebuild-dependents ./crash.swift  ./main.swift ./other.swift -module-name main -j1 -v 2>&1 | %FileCheck -check-prefix=CHECK-THIRD %s
 

test/Driver/Dependencies/dependencies-preservation-fine.swift

@@ -16,5 +16,5 @@
 // CHECK-OVERWRITTEN: options: "{{.*}}"
 // CHECK-OVERWRITTEN: build_time: [{{[0-9]*}}, {{[0-9]*}}]
 // CHECK-OVERWRITTEN: inputs:
-// CHECK-OVERWRITTEN: "./main.swift": [443865900, 0]
-// CHECK-OVERWRITTEN: "./other.swift": [443865900, 0]
+// CHECK-OVERWRITTEN: "{{(./)?}}main.swift": [443865900, 0]
+// CHECK-OVERWRITTEN: "{{(./)?}}other.swift": [443865900, 0]