libswift: add an instruction pass to simplify begin_cow_mutation instructions

* Replace the uniqueness result of a begin_cow_mutation of an empty Array/Set/Dictionary singleton with zero.
* Remove empty begin_cow_mutation - end_cow_mutation pairs
* Remove empty end_cow_mutation - begin_cow_mutation pairs

Author: eeckstein

include/swift/SILOptimizer/PassManager/Passes.def

@@ -431,6 +431,7 @@ PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)
 
+SWIFT_INSTRUCTION_PASS(BeginCOWMutationInst, "simplify-begin_cow_mutation")
 SWIFT_INSTRUCTION_PASS_WITH_LEGACY(GlobalValueInst, "simplify-global_value")
 SWIFT_INSTRUCTION_PASS_WITH_LEGACY(StrongRetainInst, "simplify-strong_retain")
 SWIFT_INSTRUCTION_PASS_WITH_LEGACY(StrongReleaseInst, "simplify-strong_release")

lib/SILOptimizer/Transforms/COWOpts.cpp

@@ -58,10 +58,6 @@ namespace {
 /// The optimization can also handle def-use chains between end_cow_mutation and
 /// begin_cow_mutation which involve phi-arguments.
 ///
-/// An additional peephole optimization is performed: if the begin_cow_mutation
-/// is the only use of the end_cow_mutation, the whole pair of instructions
-/// is eliminated.
-///
 class COWOptsPass : public SILFunctionTransform {
 public:
   COWOptsPass() {}
@@ -86,18 +82,19 @@ void COWOptsPass::run() {
   if (!F->shouldOptimize())
     return;
 
-  LLVM_DEBUG(llvm::dbgs() << "*** RedundantPhiElimination on function: "
+  LLVM_DEBUG(llvm::dbgs() << "*** COW optimization on function: "
                           << F->getName() << " ***\n");
 
   AA = PM->getAnalysis<AliasAnalysis>(F);
 
   bool changed = false;
   for (SILBasicBlock &block : *F) {
-    auto iter = block.begin();
-    while (iter != block.end()) {
-      SILInstruction *inst = &*iter++;
-      if (auto *beginCOW = dyn_cast<BeginCOWMutationInst>(inst))
-        changed |= optimizeBeginCOW(beginCOW);
+  
+    for (SILInstruction &inst : block) {
+      if (auto *beginCOW = dyn_cast<BeginCOWMutationInst>(&inst)) {
+        if (optimizeBeginCOW(beginCOW))
+          changed = true;
+      }
     }
   }
 
@@ -212,20 +209,6 @@ bool COWOptsPass::optimizeBeginCOW(BeginCOWMutationInst *BCM) {
                                     BCM->getUniquenessResult()->getType(), 1);
   BCM->getUniquenessResult()->replaceAllUsesWith(IL);
 
-  // Try the peephole optimization: remove an end_cow_mutation/begin_cow_mutation
-  // pair completely if the begin_cow_mutation is the only use of
-  // end_cow_mutation.
-  if (auto *singleEndCOW = dyn_cast<EndCOWMutationInst>(BCM->getOperand())) {
-    assert(endCOWMutationInsts.size() == 1 &&
-           *endCOWMutationInsts.begin() == singleEndCOW);
-    if (singleEndCOW->hasOneUse()) {
-      BCM->getBufferResult()->replaceAllUsesWith(singleEndCOW->getOperand());
-      BCM->eraseFromParent();
-      singleEndCOW->eraseFromParent();
-      return true;
-    }
-  }
-
   for (EndCOWMutationInst *ECM : endCOWMutationInsts) {
     // This is important for other optimizations: The code is now relying on
     // the buffer to be unique.

libswift/Sources/Optimizer/InstructionPasses/CMakeLists.txt

@@ -7,5 +7,6 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 libswift_sources(Optimizer
+  SimplifyBeginCOWMutation.swift
   SimplifyGlobalValue.swift
   SimplifyStrongRetainRelease.swift)

libswift/Sources/Optimizer/InstructionPasses/SimplifyBeginCOWMutation.swift

@@ -0,0 +1,128 @@
+//===--- SimplifyBeginCOWMutation.swift - Simplify begin_cow_mutation -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+/// Simplify begin_cow_mutation instructions.
+let simplifyBeginCOWMutationPass = InstructionPass<BeginCOWMutationInst>(
+  name: "simplify-begin_cow_mutation", {
+  (beginCOW: BeginCOWMutationInst, context: PassContext) in
+
+  /// The buffer of an empty Array/Set/Dictionary singleton is known to be not
+  /// unique. Replace the uniqueness result of such a
+  /// `begin_cow_mutation` with a zero `integer_literal`, e.g.
+  ///
+  ///   %3 = global_addr @_swiftEmptyArrayStorage
+  ///   %4 = address_to_pointer %3
+  ///   %5 = raw_pointer_to_ref %4
+  ///   %6 = unchecked_ref_cast %5
+  ///   (%u, %b) = begin_cow_mutation %6
+  /// ->
+  ///   [...]
+  ///   (%not_used, %b) = begin_cow_mutation %6
+  ///   %u = integer_literal $Builtin.Int1, 0
+  ///
+  optimizeEmptySingleton(beginCOW, context)
+
+  /// If the only use of the `begin_cow_instruction` is an `end_cow_instruction`,
+  /// remove the pair, e.g.
+  ///
+  ///   (%u, %b) = begin_cow_mutation %0 : $Buffer
+  ///   %e = end_cow_mutation %b : $Buffer
+  ///
+  if optimizeEmptyBeginEndPair(beginCOW, context) {
+    return
+  }
+
+  /// If the operand of the `begin_cow_instruction` is an `end_cow_instruction`,
+  /// which has no other uses, remove the pair, e.g.
+  ///
+  ///   %e = end_cow_mutation %0 : $Buffer
+  ///   (%u, %b) = begin_cow_mutation %e : $Buffer
+  ///
+  if optimizeEmptyEndBeginPair(beginCOW, context) {
+    return
+  }
+})
+
+private func optimizeEmptySingleton(_ beginCOW: BeginCOWMutationInst,
+                                       _ context: PassContext) {
+  if !isEmptyCOWSingleton(beginCOW.operand) {
+    return
+  }
+  if beginCOW.uniquenessResult.nonDebugUses.isEmpty {
+    /// Don't create an integer_literal which would be dead. This would result
+    /// in an infinite loop in SILCombine.
+    return
+  }
+  let builder = Builder(at: beginCOW, location: beginCOW.location, context)
+  let zero = builder.createIntegerLiteral(0, type: beginCOW.uniquenessResult.type);
+  context.replaceAllUses(of: beginCOW.uniquenessResult, with: zero)
+}
+
+private func isEmptyCOWSingleton(_ value: Value) -> Bool {
+  var v = value
+  while true {
+    switch v {
+      case is UncheckedRefCastInst,
+           is UpcastInst,
+           is RawPointerToRefInst,
+           is AddressToPointerInst,
+           is CopyValueInst:
+        v = (v as! UnaryInstruction).operand
+      case let globalAddr as GlobalAddrInst:
+        let name = globalAddr.global.name
+        return name == "_swiftEmptyArrayStorage" ||
+               name == "_swiftEmptyDictionarySingleton" ||
+               name == "_swiftEmptySetSingleton"
+      default:
+        return false
+    }
+  }
+}
+
+private func optimizeEmptyBeginEndPair(_ beginCOW: BeginCOWMutationInst,
+                                       _ context: PassContext) -> Bool {
+  if !beginCOW.uniquenessResult.nonDebugUses.isEmpty {
+    return false
+  }
+  let buffer = beginCOW.bufferResult
+  if buffer.nonDebugUses.contains(where: { !($0.instruction is EndCOWMutationInst) }) {
+    return false
+  }
+
+  for use in buffer.nonDebugUses {
+    let endCOW = use.instruction as! EndCOWMutationInst
+    context.replaceAllUses(of: endCOW, with: beginCOW.operand)
+    context.erase(instruction: endCOW)
+  }
+  context.erase(instruction: beginCOW, .includingDebugUses)
+  return true
+}
+
+private func optimizeEmptyEndBeginPair(_ beginCOW: BeginCOWMutationInst,
+                                       _ context: PassContext) -> Bool {
+  if !beginCOW.uniquenessResult.nonDebugUses.isEmpty {
+    return false
+  }
+  guard let endCOW = beginCOW.operand as? EndCOWMutationInst else {
+    return false
+  }
+  if endCOW.nonDebugUses.contains(where: { $0.instruction != beginCOW }) {
+    return false
+  }
+
+  context.replaceAllUses(of: beginCOW.bufferResult, with: endCOW.operand)
+  context.erase(instruction: beginCOW, .includingDebugUses)
+  context.erase(instruction: endCOW, .includingDebugUses)
+  return true
+}

libswift/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -40,6 +40,7 @@ private func registerPass<InstType: Instruction>(
 private func registerSwiftPasses() {
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
   registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })
+  registerPass(simplifyBeginCOWMutationPass, { simplifyBeginCOWMutationPass.run($0) })
   registerPass(simplifyGlobalValuePass, { simplifyGlobalValuePass.run($0) })
   registerPass(simplifyStrongRetainPass, { simplifyStrongRetainPass.run($0) })
   registerPass(simplifyStrongReleasePass, { simplifyStrongReleasePass.run($0) })

test/SILOptimizer/cow_opts.sil

@@ -13,19 +13,6 @@ final class Buffer {
 
 sil @unknown : $@convention(thin) (@guaranteed Buffer) -> ()
 
-// CHECK-LABEL: sil @test_complete_removal
-// CHECK:   [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
-// CHECK:   [[T:%[0-9]+]] = tuple ([[I]] : $Builtin.Int1, %0 : $Buffer)
-// CHECK:   return [[T]]
-// CHECK: } // end sil function 'test_complete_removal'
-sil @test_complete_removal : $@convention(thin) (@owned Buffer) -> (Builtin.Int1, @owned Buffer) {
-bb0(%0 : $Buffer):
-  %e = end_cow_mutation %0 : $Buffer
-  (%u, %b) = begin_cow_mutation %e : $Buffer
-  %t = tuple (%u : $Builtin.Int1, %b : $Buffer)
-  return %t : $(Builtin.Int1, Buffer)
-}
-
 // CHECK-LABEL: sil @test_simple
 // CHECK:   [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
 // CHECK:   ({{.*}}, [[B:%[0-9]+]]) = begin_cow_mutation

test/SILOptimizer/sil_combine_cow.sil

@@ -0,0 +1,106 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -sil-combine | %FileCheck %s
+
+// REQUIRES: libswift
+
+import Builtin
+import Swift
+import SwiftShims
+
+class Buffer {}
+
+sil_global @_swiftEmptyArrayStorage : $_SwiftEmptyArrayStorage
+
+// CHECK-LABEL: sil [ossa] @remove_end_begin_cow_pair
+// CHECK-NOT: end_cow_mutation
+// CHECK-NOT: begin_cow_mutation
+// CHECK:     return %0
+// CHECK: } // end sil function 'remove_end_begin_cow_pair'
+sil [ossa] @remove_end_begin_cow_pair : $@convention(thin) (@owned Buffer) -> @owned Buffer {
+bb0(%0 : @owned $Buffer):
+  %e = end_cow_mutation %0 : $Buffer
+  debug_value %e : $Buffer, var, name "x"
+  (%u, %b) = begin_cow_mutation %e : $Buffer
+  return %b : $Buffer
+}
+
+// CHECK-LABEL: sil [ossa] @dont_remove_end_begin_cow_pair1
+// CHECK:   end_cow_mutation
+// CHECK:   begin_cow_mutation
+// CHECK: } // end sil function 'dont_remove_end_begin_cow_pair1'
+sil [ossa] @dont_remove_end_begin_cow_pair1 : $@convention(thin) (@owned Buffer) -> @owned (Buffer, Buffer) {
+bb0(%0 : @owned $Buffer):
+  %e = end_cow_mutation %0 : $Buffer
+  %c = copy_value %e : $Buffer
+  (%u, %b) = begin_cow_mutation %e : $Buffer
+  %t = tuple (%c : $Buffer, %b : $Buffer)
+  return %t : $(Buffer, Buffer)
+}
+
+// CHECK-LABEL: sil [ossa] @dont_remove_end_begin_cow_pair2
+// CHECK:   end_cow_mutation
+// CHECK:   begin_cow_mutation
+// CHECK: } // end sil function 'dont_remove_end_begin_cow_pair2'
+sil [ossa] @dont_remove_end_begin_cow_pair2 : $@convention(thin) (@owned Buffer) -> @owned (Builtin.Int1, Buffer) {
+bb0(%0 : @owned $Buffer):
+  %e = end_cow_mutation %0 : $Buffer
+  (%u, %b) = begin_cow_mutation %e : $Buffer
+  %t = tuple (%u : $Builtin.Int1, %b : $Buffer)
+  return %t : $(Builtin.Int1, Buffer)
+}
+
+// CHECK-LABEL: sil [ossa] @remove_begin_end_cow_pair
+// CHECK-NOT: end_cow_mutation
+// CHECK-NOT: begin_cow_mutation
+// CHECK:     return %0
+// CHECK: } // end sil function 'remove_begin_end_cow_pair'
+sil [ossa] @remove_begin_end_cow_pair : $@convention(thin) (@owned Buffer) -> @owned Buffer {
+bb0(%0 : @owned $Buffer):
+  (%u, %b) = begin_cow_mutation %0 : $Buffer
+  debug_value %u : $Builtin.Int1, var, name "x"
+  debug_value %b : $Buffer, var, name "y"
+  %e = end_cow_mutation %b : $Buffer
+  return %e : $Buffer
+}
+
+// CHECK-LABEL: sil [ossa] @dont_remove_begin_end_cow_pair1
+// CHECK:   begin_cow_mutation
+// CHECK:   end_cow_mutation
+// CHECK: } // end sil function 'dont_remove_begin_end_cow_pair1'
+sil [ossa] @dont_remove_begin_end_cow_pair1 : $@convention(thin) (@owned Buffer) -> @owned (Buffer, Buffer) {
+bb0(%0 : @owned $Buffer):
+  (%u, %b) = begin_cow_mutation %0 : $Buffer
+  %c = copy_value %b : $Buffer
+  %e = end_cow_mutation %b : $Buffer
+  %t = tuple (%c : $Buffer, %e : $Buffer)
+  return %t : $(Buffer, Buffer)
+}
+
+// CHECK-LABEL: sil [ossa] @dont_remove_begin_end_cow_pair2
+// CHECK:   begin_cow_mutation
+// CHECK:   end_cow_mutation
+// CHECK: } // end sil function 'dont_remove_begin_end_cow_pair2'
+sil [ossa] @dont_remove_begin_end_cow_pair2 : $@convention(thin) (@owned Buffer) -> @owned (Builtin.Int1, Buffer) {
+bb0(%0 : @owned $Buffer):
+  (%u, %b) = begin_cow_mutation %0 : $Buffer
+  %e = end_cow_mutation %b : $Buffer
+  %t = tuple (%u : $Builtin.Int1, %e : $Buffer)
+  return %t : $(Builtin.Int1, Buffer)
+}
+
+// CHECK-LABEL: sil @optimize_empty_cow_singleton
+// CHECK:   [[I:%[0-9]+]] = integer_literal $Builtin.Int1, 0
+// CHECK:   begin_cow_mutation
+// CHECK:   [[T:%[0-9]+]] = tuple ([[I]]
+// CHECK:   return [[T]]
+// CHECK: } // end sil function 'optimize_empty_cow_singleton'
+sil @optimize_empty_cow_singleton : $@convention(thin) () -> (Builtin.Int1, @owned Builtin.BridgeObject) {
+bb0:
+  %3 = global_addr @_swiftEmptyArrayStorage : $*_SwiftEmptyArrayStorage
+  %4 = address_to_pointer %3 : $*_SwiftEmptyArrayStorage to $Builtin.RawPointer
+  %5 = raw_pointer_to_ref %4 : $Builtin.RawPointer to $__EmptyArrayStorage
+  %6 = unchecked_ref_cast %5 : $__EmptyArrayStorage to $Builtin.BridgeObject
+  (%u, %b) = begin_cow_mutation %6 : $Builtin.BridgeObject
+  %t = tuple (%u : $Builtin.Int1, %b : $Builtin.BridgeObject)
+  return %t : $(Builtin.Int1, Builtin.BridgeObject)
+}
+