Merge pull request #5501 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -19,6 +19,7 @@ swift_compiler_sources(Optimizer
   SimplifyInitEnumDataAddr.swift
   SimplifyLoad.swift
   SimplifyPartialApply.swift
+  SimplifyRetainReleaseValue.swift
   SimplifyStrongRetainRelease.swift
   SimplifyStructExtract.swift
   SimplifyTupleExtract.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyRetainReleaseValue.swift

@@ -0,0 +1,153 @@
+//===--- SimplifyRetainReleaseValue.swift ---------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+
+extension RetainValueInst : Simplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+
+    // Remove pairs of
+    // ```
+    //   release_value %0   // the release is before the retain!
+    //   retain_value %0
+    // ```
+    // which sometimes the ARC optimizations cannot do.
+    //
+    if optimizeReleaseRetainPair(context) {
+      return
+    }
+
+    // Replace
+    // ```
+    //   %1 = enum #E.A, %0
+    //   retain_value %1
+    // ```
+    // with
+    // ```
+    //   %1 = enum #E.A, %0   // maybe dead
+    //   retain_value %0
+    // ```
+    replaceOperandWithPayloadOfEnum(context)
+
+    // Remove if the operand is trivial (but not necessarily its type), e.g.
+    // ```
+    //   %1 = value_to_bridge_object %0 : $UInt64
+    //   retain_value %1 : $Builtin.BridgeObject
+    // ```
+    if removeIfOperandIsTrivial(context) {
+      return
+    }
+
+    // Replace e.g.
+    // ```
+    //   retain_value %1 : $SomeClass
+    // ```
+    // with
+    // ```
+    //   strong_retain %1 : $SomeClass
+    // ```
+    replaceWithStrongOrUnownedRetain(context)
+  }
+}
+
+extension ReleaseValueInst : Simplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+
+    // Replace
+    // ```
+    //   %1 = enum #E.A, %0
+    //   release_value %1
+    // ```
+    // with
+    // ```
+    //   %1 = enum #E.A, %0   // maybe dead
+    //   release_value %0
+    // ```
+    replaceOperandWithPayloadOfEnum(context)
+
+    // Remove if the operand is trivial (but not necessarily its type), e.g.
+    // ```
+    //   %1 = value_to_bridge_object %0 : $UInt64
+    //   release_value %1 : $Builtin.BridgeObject
+    // ```
+    if removeIfOperandIsTrivial(context) {
+      return
+    }
+
+    // Replace e.g.
+    // ```
+    //   release_value %1 : $SomeClass
+    // ```
+    // with
+    // ```
+    //   release_value %1 : $SomeClass
+    // ```
+    replaceWithStrongOrUnownedRelease(context)
+  }
+}
+
+private extension RetainValueInst {
+  func optimizeReleaseRetainPair(_ context: SimplifyContext) -> Bool {
+    if let prevInst = self.previous,
+       let release = prevInst as? ReleaseValueInst,
+       release.value == self.value {
+      context.erase(instruction: release)
+      context.erase(instruction: self)
+      return true
+    }
+    return false
+  }
+
+  func replaceWithStrongOrUnownedRetain(_ context: SimplifyContext) {
+    if value.type.isReferenceCounted(in: parentFunction) {
+      let builder = Builder(before: self, context)
+      if value.type.isUnownedStorageType {
+        builder.createUnownedRetain(operand: value)
+      } else {
+        builder.createStrongRetain(operand: value)
+      }
+      context.erase(instruction: self)
+    }
+  }
+}
+
+private extension ReleaseValueInst {
+  func replaceWithStrongOrUnownedRelease(_ context: SimplifyContext) {
+    if value.type.isReferenceCounted(in: parentFunction) {
+      let builder = Builder(before: self, context)
+      if value.type.isUnownedStorageType {
+        builder.createUnownedRelease(operand: value)
+      } else {
+        builder.createStrongRelease(operand: value)
+      }
+      context.erase(instruction: self)
+    }
+  }
+}
+
+private extension UnaryInstruction {
+  func replaceOperandWithPayloadOfEnum(_ context: SimplifyContext) {
+    if let e = operand.value as? EnumInst,
+       !e.type.isValueTypeWithDeinit,
+       let payload = e.payload {
+      operand.set(to: payload, context)
+    }
+  }
+
+  func removeIfOperandIsTrivial(_ context: SimplifyContext) -> Bool {
+    if operand.value.isTrivial(context) {
+      context.erase(instruction: self)
+      return true
+    }
+    return false
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -87,6 +87,8 @@ private func registerSwiftPasses() {
   registerForSILCombine(GlobalValueInst.self,      { run(GlobalValueInst.self, $0) })
   registerForSILCombine(StrongRetainInst.self,     { run(StrongRetainInst.self, $0) })
   registerForSILCombine(StrongReleaseInst.self,    { run(StrongReleaseInst.self, $0) })
+  registerForSILCombine(RetainValueInst.self,      { run(RetainValueInst.self, $0) })
+  registerForSILCombine(ReleaseValueInst.self,     { run(ReleaseValueInst.self, $0) })
   registerForSILCombine(LoadInst.self,             { run(LoadInst.self, $0) })
 
   // Test passes

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -16,6 +16,43 @@ extension Value {
   var nonDebugUses: LazyFilterSequence<UseList> {
     uses.lazy.filter { !($0.instruction is DebugValueInst) }
   }
+
+  /// Walks over all fields of an aggregate and checks if a reference count
+  /// operation for this value is required. This differs from a simple `Type.isTrivial`
+  /// check, because it treats a value_to_bridge_object instruction as "trivial".
+  /// It can also handle non-trivial enums with trivial cases.
+  func isTrivial(_ context: some Context) -> Bool {
+    if self is Undef {
+      return true
+    }
+    var worklist = ValueWorklist(context)
+    defer { worklist.deinitialize() }
+
+    worklist.pushIfNotVisited(self)
+    while let v = worklist.pop() {
+      if v.type.isTrivial(in: parentFunction) {
+        continue
+      }
+      if v.type.isValueTypeWithDeinit {
+        return false
+      }
+      switch v {
+      case is ValueToBridgeObjectInst:
+        break
+      case is StructInst, is TupleInst:
+        let inst = (v as! SingleValueInstruction)
+        worklist.pushIfNotVisited(contentsOf: inst.operands.values.filter { !($0 is Undef) })
+      case let en as EnumInst:
+        if let payload = en.payload,
+           !(payload is Undef) {
+          worklist.pushIfNotVisited(payload)
+        }
+      default:
+        return false
+      }
+    }
+    return true
+  }
 }
 
 extension Builder {

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -80,7 +80,7 @@ extension ApplySite {
   ///
   /// This does not include the callee function operand.
   public var arguments: LazyMapSequence<OperandArray, Value> {
-    argumentOperands.lazy.map { $0.value }
+    argumentOperands.values
   }
 
   public var substitutionMap: SubstitutionMap {

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -136,6 +136,18 @@ public struct Builder {
     return notifyNew(release.getAs(StrongReleaseInst.self))
   }
 
+  @discardableResult
+  public func createUnownedRetain(operand: Value) -> UnownedRetainInst {
+    let retain = bridged.createUnownedRetain(operand.bridged)
+    return notifyNew(retain.getAs(UnownedRetainInst.self))
+  }
+
+  @discardableResult
+  public func createUnownedRelease(operand: Value) -> UnownedReleaseInst {
+    let release = bridged.createUnownedRelease(operand.bridged)
+    return notifyNew(release.getAs(UnownedReleaseInst.self))
+  }
+
   public func createFunctionRef(_ function: Function) -> FunctionRefInst {
     let functionRef = bridged.createFunctionRef(function.bridged)
     return notifyNew(functionRef.getAs(FunctionRefInst.self))

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -197,7 +197,7 @@ public class MultipleValueInstruction : Instruction {
 }
 
 /// Instructions, which have a single operand.
-public protocol UnaryInstruction : AnyObject {
+public protocol UnaryInstruction : Instruction {
   var operands: OperandArray { get }
   var operand: Operand { get }
 }
@@ -306,14 +306,24 @@ final public class StrongRetainInst : RefCountingInst {
   public var instance: Value { operand.value }
 }
 
+final public class UnownedRetainInst : RefCountingInst {
+  public var instance: Value { operand.value }
+}
+
 final public class RetainValueInst : RefCountingInst {
+  public var value: Value { return operand.value }
 }
 
 final public class StrongReleaseInst : RefCountingInst {
   public var instance: Value { operand.value }
 }
 
+final public class UnownedReleaseInst : RefCountingInst {
+  public var instance: Value { operand.value }
+}
+
 final public class ReleaseValueInst : RefCountingInst {
+  public var value: Value { return operand.value }
 }
 
 final public class DestroyValueInst : Instruction, UnaryInstruction {

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -76,6 +76,10 @@ public struct OperandArray : RandomAccessCollection, CustomReflectable {
       base: OptionalBridgedOperand(op: base.advancedBy(bounds.lowerBound).op),
       count: bounds.upperBound - bounds.lowerBound)
   }
+
+  public var values: LazyMapSequence<LazySequence<OperandArray>.Elements, Value> {
+    self.lazy.map { $0.value }
+  }
 }
 
 public struct UseList : CollectionLikeSequence {

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -54,8 +54,10 @@ public func registerSILClasses() {
   register(EndApplyInst.self)
   register(AbortApplyInst.self)
   register(StrongRetainInst.self)
+  register(UnownedRetainInst.self)
   register(RetainValueInst.self)
   register(StrongReleaseInst.self)
+  register(UnownedReleaseInst.self)
   register(ReleaseValueInst.self)
   register(DestroyValueInst.self)
   register(DestroyAddrInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -31,6 +31,10 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     return !bridged.isNonTrivialOrContainsRawPointer(function.bridged.getFunction())
   }
 
+  /// True if this type is a value type (struct/enum) that requires deinitialization beyond
+  /// destruction of its members.
+  public var isValueTypeWithDeinit: Bool { bridged.isValueTypeWithDeinit() }
+
   public func isLoadable(in function: Function) -> Bool {
     return bridged.isLoadable(function.bridged.getFunction())
   }
@@ -39,6 +43,10 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     return bridged.isReferenceCounted(function.bridged.getFunction())
   }
 
+  public var isUnownedStorageType: Bool {
+    return bridged.isUnownedStorageType()
+  }
+
   public var hasArchetype: Bool { bridged.hasArchetype() }
 
   public var isNominal: Bool { bridged.getNominalOrBoundGenericNominal() != nil }