[pull] swiftwasm from main

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 }

cmake/modules/AddPureSwift.cmake

@@ -141,6 +141,12 @@ function(add_pure_swift_host_library name)
   set_property(TARGET ${name}
     PROPERTY BUILD_WITH_INSTALL_RPATH YES)
 
+  if(APSHL_SHARED AND CMAKE_SYSTEM_NAME STREQUAL Darwin)
+    # Allow install_name_tool to update paths (for rdar://109473564)
+    set_property(TARGET ${name} APPEND_STRING PROPERTY
+                 LINK_FLAGS " -Xlinker -headerpad_max_install_names")
+  endif()
+
   # Respect LLVM_COMMON_DEPENDS if it is set.
   #
   # LLVM_COMMON_DEPENDS if a global variable set in ./lib that provides targets
@@ -157,7 +163,7 @@ function(add_pure_swift_host_library name)
   add_custom_command(
       TARGET ${name}
       POST_BUILD
-      COMMAND "${CMAKE_COMMAND}" -E touch_nocreate $<TARGET_FILE:${name}> $<TARGET_OBJECTS:${name}>
+      COMMAND "${CMAKE_COMMAND}" -E touch_nocreate $<TARGET_FILE:${name}> $<TARGET_OBJECTS:${name}> "${SWIFT_HOST_LIBRARIES_DEST_DIR}/${name}.swiftmodule" "${CMAKE_CURRENT_BINARY_DIR}/${name}.swiftmodule"
       COMMAND_EXPAND_LISTS
       COMMENT "Update mtime of library outputs workaround")
 
@@ -298,6 +304,24 @@ function(add_pure_swift_host_tool name)
   target_include_directories(${name} PUBLIC
     ${SWIFT_HOST_LIBRARIES_DEST_DIR})
 
+  # Workaround to touch the library and its objects so that we don't
+  # continually rebuild (again, see corresponding change in swift-syntax).
+  add_custom_command(
+      TARGET ${name}
+      POST_BUILD
+      COMMAND "${CMAKE_COMMAND}" -E touch_nocreate $<TARGET_FILE:${name}> $<TARGET_OBJECTS:${name}>
+      COMMAND_EXPAND_LISTS
+      COMMENT "Update mtime of executable outputs workaround")
+
+  # Even worse hack - ${name}.swiftmodule is added as an output, even though
+  # this is an executable target. Just touch it all the time to avoid having
+  # to rebuild it every time.
+  add_custom_command(
+      TARGET ${name}
+      POST_BUILD
+      COMMAND "${CMAKE_COMMAND}" -E touch "${CMAKE_CURRENT_BINARY_DIR}/${name}.swiftmodule"
+      COMMAND_EXPAND_LISTS
+      COMMENT "Update mtime of executable outputs workaround")
   # Export this target.
   set_property(GLOBAL APPEND PROPERTY SWIFT_EXPORTS ${name})
 endfunction()

docs/CppInteroperability/CppInteroperabilityManifesto.md

@@ -2,7 +2,9 @@
 
 # ⚠️ Warning: document is out of date. ⚠️
 
-**This document has not had significant updates in the last three years. The goals and design outlined here do not necessarily reflect those established by the C++ Interop Work Group. For an up-to-date document, please see [the Forward Vision which is being developed here](https://github.com/zoecarver/swift/blob/docs/interop-roadmap/docs/CppInteroperability/ForwardVision.md).**
+**This document has not had significant updates in the last three years. The goals and design outlined here do not necessarily reflect those established by the C++ Interop Work Group. For an up-to-date document, please see [the Forward Vision document](https://github.com/apple/swift-evolution/blob/main/visions/using-swift-from-c%2B%2B.md).**
+
+[** ‼️ Additionally, the official C++ interoperability documentation is live at Swift.org and provides an up-to-date guide for mixing Swift and C++ ‼️ **](https://www.swift.org/documentation/cxx-interop/)
 
 This document discusses the design and tradeoffs for bidirectional API-level
 interoperability between Swift and C++.

docs/CppInteroperability/CppInteroperabilityStatus.md

@@ -1,3 +1,5 @@
+[** ‼️ The official C++ interoperability documentation and status page is live at Swift.org and provides an up-to-date guide for mixing Swift and C++ ‼️ **](https://www.swift.org/documentation/cxx-interop/status)
+
 #  C++ Interoperability Status
 
 Swift has some experimental ability to interoperate with C++.

docs/CppInteroperability/GettingStartedWithC++Interop.md

@@ -1,3 +1,5 @@
+[** ‼️ The official C++ interoperability documentation is live at Swift.org and provides an up-to-date guide for mixing Swift and C++ ‼️ **](https://www.swift.org/documentation/cxx-interop/)
+
 # Getting started with C++ Interoperability
 
 This document is designed to get you started with bidirectional API-level interoperability between Swift and C++.

docs/CppInteroperability/InteropOddities.md

@@ -1,3 +1,5 @@
+[** ‼️ The official C++ interoperability documentation is live at Swift.org and provides an up-to-date guide for mixing Swift and C++ ‼️ **](https://www.swift.org/documentation/cxx-interop/)
+
 # C++ Interoperability Oddities
 
 C++ APIs may have slightly different behavior than other C++ APIs. This is a general catch-all document where these