Merge pull request #5174 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

.github/CODEOWNERS

@@ -62,6 +62,12 @@ cmake/**/*Windows*    @compnerd
 lib/Basic/Windows     @compnerd
 utils/*windows*       @compnerd
 
+# Repository checkout utils
+
+/utils/update_checkout/ @shahmishal
+/utils/update-checkout* @shahmishal
+
+
 # AST
 /include/swift/AST/               @hborla @slavapestov @xedin
 /include/swift/AST/*Conformance*  @slavapestov

CMakeLists.txt

@@ -268,7 +268,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.8")
+set(SWIFT_VERSION "5.9")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")
@@ -570,6 +570,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING
   "Enable experimental string processing"
   FALSE)
 
+option(SWIFT_ENABLE_EXPERIMENTAL_REFLECTION
+  "Enable build of the Swift reflection module"
+  FALSE)
+
 option(SWIFT_ENABLE_DISPATCH
   "Enable use of libdispatch"
   TRUE)
@@ -1115,6 +1119,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Distributed Support:                ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")
   message(STATUS "String Processing Support:          ${SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING}")
   message(STATUS "Unicode Support:                    ${SWIFT_STDLIB_ENABLE_UNICODE_DATA}")
+  message(STATUS "Reflection Support:                 ${SWIFT_ENABLE_EXPERIMENTAL_REFLECTION}")
   message(STATUS "")
 else()
   message(STATUS "Not building Swift standard library, SDK overlays, and runtime")

SwiftCompilerSources/README.md

@@ -156,9 +156,9 @@ With instruction passes it's possible to implement small peephole optimizations
 
 To add a new instruction pass:
 
-* add a `SWIFT_INSTRUCTION_PASS` entry in `Passes.def`
+* add a `SWIFT_SILCOMBINE_PASS` entry in `Passes.def`
 * create a new Swift file in `SwiftCompilerSources/Optimizer/InstructionPasses`
-* add an `InstructionPass` global
+* implement the `simplify` function in conformance to `SILCombineSimplifyable`
 * register the pass in `registerSwiftPasses()`
 * if this pass replaces an existing `SILCombiner` visit function, remove the old visit function
 

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -65,7 +65,7 @@ struct AliasAnalysis {
     AliasAnalysis_register(
       // getMemEffectsFn
       { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> BridgedMemoryBehavior in
-        let context = PassContext(_bridged: bridgedCtxt)
+        let context = FunctionPassContext(_bridged: bridgedCtxt)
         let inst = bridgedInst.instruction
         let val = bridgedVal.value
         let path = AliasAnalysis.getPtrOrAddressPath(for: val)
@@ -78,28 +78,28 @@ struct AliasAnalysis {
             case (true, true):   return MayReadWriteBehavior
           }
         }
-        if val.at(path).isAddressEscaping(using: EscapesToInstructionVisitor(target: inst), context) {
+        if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
           return MayReadWriteBehavior
         }
         return NoneBehavior
       },
 
       // isObjReleasedFn
       { (bridgedCtxt: BridgedPassContext, bridgedObj: BridgedValue, bridgedInst: BridgedInstruction) -> Bool in
-        let context = PassContext(_bridged: bridgedCtxt)
+        let context = FunctionPassContext(_bridged: bridgedCtxt)
         let inst = bridgedInst.instruction
         let obj = bridgedObj.value
         let path = SmallProjectionPath(.anyValueFields)
         if let apply = inst as? ApplySite {
           let effect = getOwnershipEffect(of: apply, for: obj, path: path, context)
           return effect.destroy
         }
-        return obj.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst), context)
+        return obj.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: false), context)
       },
 
       // isAddrVisibleFromObj
       { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Bool in
-        let context = PassContext(_bridged: bridgedCtxt)
+        let context = FunctionPassContext(_bridged: bridgedCtxt)
         let addr = bridgedAddr.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedAddr.value))
 
         // This is similar to `canReferenceSameFieldFn`, except that all addresses of all objects are
@@ -110,7 +110,7 @@ struct AliasAnalysis {
 
       // canReferenceSameFieldFn
       { (bridgedCtxt: BridgedPassContext, bridgedLhs: BridgedValue, bridgedRhs: BridgedValue) -> Bool in
-        let context = PassContext(_bridged: bridgedCtxt)
+        let context = FunctionPassContext(_bridged: bridgedCtxt)
 
         // If `lhs` or `rhs` is not an address, but an object, it means: check for alias of any class
         // field address of the object.
@@ -122,13 +122,13 @@ struct AliasAnalysis {
   }
 }
 
-private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Memory {
+private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
   let calleeAnalysis = context.calleeAnalysis
-  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis)
+  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis, isAddress: true)
   let memoryEffects: SideEffects.Memory
 
   // First try to figure out to which argument(s) the address "escapes" to.
-  if let result = address.at(path).visitAddress(using: visitor, context) {
+  if let result = address.at(path).visit(using: visitor, context) {
     // The resulting effects are the argument effects to which `address` escapes to.
     memoryEffects = result.memory
   } else {
@@ -145,8 +145,8 @@ private func getMemoryEffect(of apply: ApplySite, for address: Value, path: Smal
   return memoryEffects
 }
 
-private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Ownership {
-  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis)
+private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Ownership {
+  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis, isAddress: false)
   if let result = value.at(path).visit(using: visitor, context) {
     // The resulting effects are the argument effects to which `value` escapes to.
     return result.ownership
@@ -159,6 +159,7 @@ private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: Sma
 private struct SideEffectsVisitor : EscapeVisitorWithResult {
   let apply: ApplySite
   let calleeAnalysis: CalleeAnalysis
+  let isAddress: Bool
   var result = SideEffects.GlobalEffects()
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
@@ -175,6 +176,30 @@ private struct SideEffectsVisitor : EscapeVisitorWithResult {
     }
     return .continueWalk
   }
+
+  var followTrivialTypes: Bool { isAddress }
+  var followLoads: Bool { !isAddress }
+}
+
+/// Lets `ProjectedValue.isEscaping` return true if the value is "escaping" to the `target` instruction.
+private struct EscapesToInstructionVisitor : EscapeVisitor {
+  let target: Instruction
+  let isAddress: Bool
+
+  mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+    let user = operand.instruction
+    if user == target {
+      return .abort
+    }
+    if user is ReturnInst {
+      // Anything which is returned cannot escape to an instruction inside the function.
+      return .ignore
+    }
+    return .continueWalk
+  }
+
+  var followTrivialTypes: Bool { isAddress }
+  var followLoads: Bool { !isAddress }
 }
 
 private extension Value {

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -24,7 +24,7 @@ public struct CalleeAnalysis {
       },
       // getMemBehaviorFn
       { (bridgedCtxt: BridgedPassContext, bridgedApply: BridgedInstruction, observeRetains: Bool) -> BridgedMemoryBehavior in
-        let context = PassContext(_bridged: bridgedCtxt)
+        let context = FunctionPassContext(_bridged: bridgedCtxt)
         let apply = bridgedApply.instruction as! ApplySite
         let e = context.calleeAnalysis.getSideEffects(of: apply)
         return e.getMemBehavior(observeRetains: observeRetains)

SwiftCompilerSources/Sources/Optimizer/CMakeLists.txt

@@ -13,7 +13,7 @@ add_swift_compiler_module(Optimizer DEPENDS ${dependencies})
 
 add_subdirectory(Analysis)
 add_subdirectory(DataStructures)
-add_subdirectory(InstructionPasses)
+add_subdirectory(InstructionSimplification)
 add_subdirectory(PassManager)
 add_subdirectory(ModulePasses)
 add_subdirectory(FunctionPasses)

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -66,7 +66,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   private var inExclusiveRange: BasicBlockSet
   private var worklist: BasicBlockWorklist
 
-  init(begin: BasicBlock, _ context: PassContext) {
+  init(begin: BasicBlock, _ context: some Context) {
     self.begin = begin
     self.inclusiveRange = Stack(context)
     self.inserted = Stack(context)
@@ -110,7 +110,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
 
   /// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
   var isValid: Bool {
-    let entry = begin.function.entryBlock
+    let entry = begin.parentFunction.entryBlock
     return begin == entry ||
       // If any block in the range is not dominated by `begin`, the range propagates back to the entry block.
       !inclusiveRangeContains(entry)

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockWorklist.swift

@@ -8,9 +8,10 @@
 
 swift_compiler_sources(Optimizer
   BasicBlockRange.swift
-  BasicBlockWorklist.swift
   DeadEndBlocks.swift
   FunctionUses.swift
   InstructionRange.swift
+  ReachableBlocks.swift
   Set.swift
-  Stack.swift)
+  Stack.swift
+  Worklist.swift)

SwiftCompilerSources/Sources/Optimizer/DataStructures/CMakeLists.txt

@@ -19,8 +19,10 @@ import SIL
 /// instruction and blocks from which all paths end in "unreachable" blocks.
 struct DeadEndBlocks : CustomStringConvertible, NoReflectionChildren {
   private var worklist: BasicBlockWorklist
+  private var function: Function
 
-  init(function: Function, _ context: PassContext) {
+  init(function: Function, _ context: FunctionPassContext) {
+    self.function = function
     self.worklist = BasicBlockWorklist(context)
 
     // Initialize the worklist with all function-exiting blocks.
@@ -40,7 +42,7 @@ struct DeadEndBlocks : CustomStringConvertible, NoReflectionChildren {
   }
 
   var description: String {
-    let blockNames = worklist.function.blocks.filter(isDeadEnd).map(\.name)
+    let blockNames = function.blocks.filter(isDeadEnd).map(\.name)
     return "[" + blockNames.joined(separator: ",") + "]"
   }
 

SwiftCompilerSources/Sources/Optimizer/DataStructures/DeadEndBlocks.swift

@@ -93,7 +93,7 @@ struct FunctionUses {
         result += "<unknown uses>\n"
       }
       for inst in self {
-        result += "@\(inst.function.name): \(inst)\n"
+        result += "@\(inst.parentFunction.name): \(inst)\n"
 
       }
       result += "]"

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -48,16 +48,16 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   private var insertedInsts: InstructionSet
 
-  init(begin beginInst: Instruction, _ context: PassContext) {
+  init(begin beginInst: Instruction, _ context: some Context) {
     self.begin = beginInst
-    self.blockRange = BasicBlockRange(begin: beginInst.block, context)
+    self.blockRange = BasicBlockRange(begin: beginInst.parentBlock, context)
     self.insertedInsts = InstructionSet(context)
   }
 
   /// Insert a potential end instruction.
   mutating func insert(_ inst: Instruction) {
     insertedInsts.insert(inst)
-    blockRange.insert(inst.block)
+    blockRange.insert(inst.parentBlock)
   }
 
   /// Insert a sequence of potential end instructions.
@@ -69,7 +69,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   /// Returns true if the exclusive range contains `inst`.
   func contains(_ inst: Instruction) -> Bool {
-    let block = inst.block
+    let block = inst.parentBlock
     if !blockRange.inclusiveRangeContains(block) { return false }
     var inRange = false
     if blockRange.contains(block) {

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -0,0 +1,48 @@
+//===--- ReachableBlocks.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
+
+/// A utility for finding reachable and unreachable blocks.
+///
+/// Reachable blocks are all blocks which are reachable from the entry block of
+/// the function. All other blocks are dead blocks.
+struct ReachableBlocks : CustomStringConvertible, NoReflectionChildren {
+  private var worklist: BasicBlockWorklist
+  private var function: Function
+
+  init(function: Function, _ context: FunctionPassContext) {
+    self.function = function
+    self.worklist = BasicBlockWorklist(context)
+
+    worklist.pushIfNotVisited(function.entryBlock)
+
+    // Propagate lifeness down the control flow.
+    while let block = worklist.pop() {
+      worklist.pushIfNotVisited(contentsOf: block.successors)
+    }
+  }
+
+  func isReachable(block: BasicBlock) -> Bool {
+    return worklist.hasBeenPushed(block)
+  }
+
+  var description: String {
+    let blockNames = function.blocks.filter(isReachable).map(\.name)
+    return "[" + blockNames.joined(separator: ",") + "]"
+  }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    worklist.deinitialize()
+  }
+}