[ownership] Once we strip ownership ignoring transparent functions from our module, strip ownership as we serialize.

Author: gottesmm

lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp

@@ -284,6 +284,58 @@ bool OwnershipModelEliminatorVisitor::visitDestructureTupleInst(
 //                           Top Level Entry Point
 //===----------------------------------------------------------------------===//
 
+static bool stripOwnership(SILFunction &F) {
+  // If F is an external declaration, do not process it.
+  if (F.isExternalDeclaration())
+    return false;
+
+  // Set F to have unqualified ownership.
+  F.setOwnershipEliminated();
+
+  bool MadeChange = false;
+  SILBuilder B(F);
+  OwnershipModelEliminatorVisitor Visitor(B);
+
+  for (auto &BB : F) {
+    // Change all arguments to have ValueOwnershipKind::Any.
+    for (auto *Arg : BB.getArguments()) {
+      Arg->setOwnershipKind(ValueOwnershipKind::Any);
+    }
+
+    for (auto II = BB.begin(), IE = BB.end(); II != IE;) {
+      // Since we are going to be potentially removing instructions, we need
+      // to make sure to increment our iterator before we perform any
+      // visits.
+      SILInstruction *I = &*II;
+      ++II;
+
+      MadeChange |= Visitor.visit(I);
+    }
+  }
+  return MadeChange;
+}
+
+static void prepareNonTransparentSILFunctionForOptimization(ModuleDecl *,
+                                                            SILFunction *F) {
+  if (!F->hasOwnership() || F->isTransparent())
+    return;
+
+  LLVM_DEBUG(llvm::dbgs() << "After deserialization, stripping ownership in:"
+                          << F->getName() << "\n");
+
+  stripOwnership(*F);
+}
+
+static void prepareSILFunctionForOptimization(ModuleDecl *, SILFunction *F) {
+  if (!F->hasOwnership())
+    return;
+
+  LLVM_DEBUG(llvm::dbgs() << "After deserialization, stripping ownership in:"
+                          << F->getName() << "\n");
+
+  stripOwnership(*F);
+}
+
 namespace {
 
 struct OwnershipModelEliminator : SILModuleTransform {
@@ -297,48 +349,38 @@ struct OwnershipModelEliminator : SILModuleTransform {
       getModule()->dump(DumpBefore.c_str());
     }
 
-    for (auto &F : *getModule()) {
+    auto &Mod = *getModule();
+    for (auto &F : Mod) {
       // If F does not have ownership, skip it. We have no further work to do.
       if (!F.hasOwnership())
         continue;
 
-      // If we were asked to not strip ownership from transparent functions,
-      // continue.
+      // If we were asked to not strip ownership from transparent functions in
+      // /our/ module, continue.
       if (SkipTransparent && F.isTransparent())
         continue;
 
-      // Set F to have unqualified ownership.
-      F.setOwnershipEliminated();
-
-      bool MadeChange = false;
-      SILBuilder B(F);
-      OwnershipModelEliminatorVisitor Visitor(B);
-
-      for (auto &BB : F) {
-        // Change all arguments to have ValueOwnershipKind::Any.
-        for (auto *Arg : BB.getArguments()) {
-          Arg->setOwnershipKind(ValueOwnershipKind::Any);
-        }
-
-        for (auto II = BB.begin(), IE = BB.end(); II != IE;) {
-          // Since we are going to be potentially removing instructions, we need
-          // to make sure to increment our iterator before we perform any
-          // visits.
-          SILInstruction *I = &*II;
-          ++II;
-
-          MadeChange |= Visitor.visit(I);
-        }
-      }
-
-      if (MadeChange) {
+      if (stripOwnership(F)) {
         auto InvalidKind =
             SILAnalysis::InvalidationKind::BranchesAndInstructions;
         invalidateAnalysis(&F, InvalidKind);
       }
     }
-  }
 
+    // If we were asked to strip transparent, we are at the beginning of the
+    // performance pipeline. In such a case, we register a handler so that all
+    // future things we deserialize have ownership stripped.
+    using NotificationHandlerTy =
+        FunctionBodyDeserializationNotificationHandler;
+    std::unique_ptr<DeserializationNotificationHandler> ptr;
+    if (SkipTransparent) {
+      ptr.reset(new NotificationHandlerTy(
+          prepareNonTransparentSILFunctionForOptimization));
+    } else {
+      ptr.reset(new NotificationHandlerTy(prepareSILFunctionForOptimization));
+    }
+    Mod.registerDeserializationNotificationHandler(std::move(ptr));
+  }
 };
 
 } // end anonymous namespace

test/SILOptimizer/Inputs/ome_strip_deserialize_input.sil

@@ -0,0 +1,14 @@
+
+sil_stage canonical
+
+sil public [serialized] [ossa] @bar : $@convention(thin) () -> () {
+bb0:
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+sil public [serialized] [transparent] [ossa] @transparent_bar : $@convention(thin) () -> () {
+bb0:
+  %9999 = tuple()
+  return %9999 : $()
+}

test/SILOptimizer/non_transparent_ome.sil renamed to test/SILOptimizer/ome_non_transparent.sil

@@ -0,0 +1,40 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -parse-sil -module-name OMEStripDeserializationInput %S/Inputs/ome_strip_deserialize_input.sil -emit-module -o %t/OMEStripDeserializationInput.swiftmodule
+// RUN: %target-sil-opt -enable-sil-ownership -non-transparent-func-ownership-model-eliminator -performance-linker -I %t %s | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-ownership -ownership-model-eliminator -performance-linker -I %t %s | %FileCheck --check-prefix=CHECK-STRIP-ALL %s
+
+sil_stage canonical
+
+import OMEStripDeserializationInput
+
+// Make sure that we properly set the deserialization call back for stripping
+// ownership SIL.
+
+// CHECK-LABEL: sil public_external [serialized] @bar : $@convention(thin) () -> ()
+// CHECK: } // end sil function 'bar'
+
+// CHECK-STRIP-ALL-LABEL: sil public_external [serialized] @bar : $@convention(thin) () -> ()
+// CHECK-STRIP-ALL: } // end sil function 'bar'
+sil [ossa] @bar : $@convention(thin) () -> ()
+
+// CHECK-LABEL: sil public_external [transparent] [serialized] [ossa] @transparent_bar : $@convention(thin) () -> ()
+// CHECK: } // end sil function 'transparent_bar'
+
+// CHECK-STRIP-ALL-LABEL: sil public_external [transparent] [serialized] @transparent_bar : $@convention(thin) () -> ()
+// CHECK-STRIP-ALL: } // end sil function 'transparent_bar'
+
+sil [transparent] [ossa] @transparent_bar : $@convention(thin) () -> ()
+
+// CHECK-LABEL: sil @foo : $@convention(thin) () -> () {
+// CHECK: } // end sil function 'foo'
+sil [ossa] @foo : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @bar : $@convention(thin) () -> ()
+  apply %0() : $@convention(thin) () -> ()
+
+  %1 = function_ref @transparent_bar : $@convention(thin) () -> ()
+  apply %1() : $@convention(thin) () -> ()
+
+  %9999 = tuple()
+  return %9999 : $()
+}