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: ",") + "]"
   }