Merge pull request #4551 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -12,6 +12,30 @@
 
 @_exported import BasicBridging
 
+//===----------------------------------------------------------------------===//
+//                              StringRef
+//===----------------------------------------------------------------------===//
+
+public struct StringRef : CustomStringConvertible, CustomReflectable {
+  let _bridged : BridgedStringRef
+
+  public init(bridged: BridgedStringRef) { self._bridged = bridged }
+
+  public var string: String { _bridged.string }
+  public var description: String { string }
+  public var customMirror: Mirror { Mirror(self, children: []) }
+  
+  public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
+    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.data, count: Int(lhs._bridged.length))
+    return rhs.withUTF8Buffer { (rhsBuffer: UnsafeBufferPointer<UInt8>) in
+      if lhsBuffer.count != rhsBuffer.count { return false }
+      return lhsBuffer.elementsEqual(rhsBuffer, by: ==)
+    }
+  }
+  
+  public static func !=(lhs: StringRef, rhs: StaticString) -> Bool { !(lhs == rhs) }
+}
+
 //===----------------------------------------------------------------------===//
 //                            Bridging Utilities
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AssumeSingleThreaded.swift

@@ -33,7 +33,7 @@ let assumeSingleThreadedPass = FunctionPass(
       for inst in block.instructions {
         guard let rcInst = inst as? RefCountingInst else { continue }
 
-        context.setAtomicity(of: rcInst, isAtomic: false)
+        rcInst.setAtomicity(isAtomic: false, context)
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -207,7 +207,8 @@ private extension EscapeInfo {
     var dominatingBlock = value.block
 
     _ = isEscaping(object: value, visitUse: { op, _, _ in
-        if let defBlock = op.value.definingBlock, defBlock.dominates(dominatingBlock, domTree) {
+        let defBlock = op.value.definingBlock
+        if defBlock.dominates(dominatingBlock, domTree) {
           dominatingBlock = defBlock
         }
         return .continueWalking
@@ -230,25 +231,25 @@ private extension EscapeInfo {
         outerBlockRange.insert(user.block)
 
         let val = op.value
-        if let defBlock = val.definingBlock {
-          // Also insert the operand's definition. Otherwise we would miss allocation
-          // instructions (for which the `visitUse` closure is not called).
-          outerBlockRange.insert(defBlock)
-          
-          // We need to explicitly add predecessor blocks of phi-arguments becaues they
-          // are not necesesarily visited by `EscapeInfo.walkDown`.
-          // This is important for the special case where there is a back-edge from the
-          // inner range to the inner rage's begin-block:
-          //
-          //   bb0:                      // <- need to be in the outer range
-          //     br bb1(%some_init_val)
-          //   bb1(%arg):
-          //     %k = alloc_ref $Klass   // innerInstRange.begin
-          //     cond_br bb2, bb1(%k)    // back-edge to bb1 == innerInstRange.blockRange.begin
-          //
-          if val is BlockArgument {
-            outerBlockRange.insert(contentsOf: defBlock.predecessors)
-          }
+        let defBlock = val.definingBlock
+
+        // Also insert the operand's definition. Otherwise we would miss allocation
+        // instructions (for which the `visitUse` closure is not called).
+        outerBlockRange.insert(defBlock)
+        
+        // We need to explicitly add predecessor blocks of phi-arguments becaues they
+        // are not necesesarily visited by `EscapeInfo.walkDown`.
+        // This is important for the special case where there is a back-edge from the
+        // inner range to the inner rage's begin-block:
+        //
+        //   bb0:                      // <- need to be in the outer range
+        //     br bb1(%some_init_val)
+        //   bb1(%arg):
+        //     %k = alloc_ref $Klass   // innerInstRange.begin
+        //     cond_br bb2, bb1(%k)    // back-edge to bb1 == innerInstRange.blockRange.begin
+        //
+        if val is BlockArgument {
+          outerBlockRange.insert(contentsOf: defBlock.predecessors)
         }
         return .continueWalking
       })

SwiftCompilerSources/Sources/Optimizer/InstructionPasses/SimplifyBeginCOWMutation.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Basic
 import SIL
 
 /// Simplify begin_cow_mutation instructions.
@@ -66,7 +67,7 @@ private func optimizeEmptySingleton(_ beginCOW: BeginCOWMutationInst,
   }
   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)
+  beginCOW.uniquenessResult.uses.replaceAll(with: zero, context)
 }
 
 private func isEmptyCOWSingleton(_ value: Value) -> Bool {
@@ -102,7 +103,7 @@ private func optimizeEmptyBeginEndPair(_ beginCOW: BeginCOWMutationInst,
 
   for use in buffer.nonDebugUses {
     let endCOW = use.instruction as! EndCOWMutationInst
-    context.replaceAllUses(of: endCOW, with: beginCOW.operand)
+    endCOW.uses.replaceAll(with: beginCOW.operand, context)
     context.erase(instruction: endCOW)
   }
   context.erase(instruction: beginCOW, .includingDebugUses)
@@ -121,7 +122,7 @@ private func optimizeEmptyEndBeginPair(_ beginCOW: BeginCOWMutationInst,
     return false
   }
 
-  context.replaceAllUses(of: beginCOW.bufferResult, with: endCOW.operand)
+  beginCOW.bufferResult.uses.replaceAll(with: endCOW.operand, context)
   context.erase(instruction: beginCOW, .includingDebugUses)
   context.erase(instruction: endCOW, .includingDebugUses)
   return true

SwiftCompilerSources/Sources/Optimizer/InstructionPasses/SimplifyStrongRetainRelease.swift

@@ -59,7 +59,7 @@ let simplifyStrongReleasePass = InstructionPass<StrongReleaseInst>(
   // release of the class, squish the conversion.
   if let ier = op as? InitExistentialRefInst {
     if ier.uses.isSingleUse {
-      context.setOperand(of: release, at: 0, to: ier.operand)
+      release.setOperand(at: 0, to: ier.operand, context)
       context.erase(instruction: ier)
       return
     }

SwiftCompilerSources/Sources/Optimizer/PassManager/CMakeLists.txt

@@ -7,6 +7,7 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
-  PassUtils.swift
+  Passes.swift
+  PassContext.swift
   PassRegistration.swift)
 

SwiftCompilerSources/Sources/Optimizer/PassManager/PassContext.swift

@@ -0,0 +1,225 @@
+//===--- PassContext.swift - defines the PassContext type -----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+import OptimizerBridging
+
+public typealias BridgedFunctionPassCtxt =
+  OptimizerBridging.BridgedFunctionPassCtxt
+public typealias BridgedInstructionPassCtxt =
+  OptimizerBridging.BridgedInstructionPassCtxt
+
+struct PassContext {
+
+  let _bridged: BridgedPassContext
+
+  func continueWithNextSubpassRun(for inst: Instruction? = nil) -> Bool {
+    let bridgedInst = OptionalBridgedInstruction(obj: inst?.bridged.obj)
+    return PassContext_continueWithNextSubpassRun(_bridged, bridgedInst) != 0
+  }
+
+  //===--------------------------------------------------------------------===//
+  //                               Analysis
+  //===--------------------------------------------------------------------===//
+
+  var aliasAnalysis: AliasAnalysis {
+    let bridgedAA = PassContext_getAliasAnalysis(_bridged)
+    return AliasAnalysis(bridged: bridgedAA)
+  }
+
+  var calleeAnalysis: CalleeAnalysis {
+    let bridgeCA = PassContext_getCalleeAnalysis(_bridged)
+    return CalleeAnalysis(bridged: bridgeCA)
+  }
+
+  var deadEndBlocks: DeadEndBlocksAnalysis {
+    let bridgeDEA = PassContext_getDeadEndBlocksAnalysis(_bridged)
+    return DeadEndBlocksAnalysis(bridged: bridgeDEA)
+  }
+
+  var dominatorTree: DominatorTree {
+    let bridgedDT = PassContext_getDomTree(_bridged)
+    return DominatorTree(bridged: bridgedDT)
+  }
+
+  var postDominatorTree: PostDominatorTree {
+    let bridgedPDT = PassContext_getPostDomTree(_bridged)
+    return PostDominatorTree(bridged: bridgedPDT)
+  }
+
+  //===--------------------------------------------------------------------===//
+  //                   Interaction with AST and the SIL module
+  //===--------------------------------------------------------------------===//
+
+  func getContextSubstitutionMap(for type: Type) -> SubstitutionMap {
+    SubstitutionMap(PassContext_getContextSubstitutionMap(_bridged, type.bridged))
+  }
+
+  func loadFunction(name: StaticString) -> Function? {
+    return name.withUTF8Buffer { (nameBuffer: UnsafeBufferPointer<UInt8>) in
+      PassContext_loadFunction(_bridged, BridgedStringRef(data: nameBuffer.baseAddress, length: nameBuffer.count)).function
+    }
+  }
+
+  //===--------------------------------------------------------------------===//
+  //                             Modify SIL
+  //===--------------------------------------------------------------------===//
+
+  /// Splits the basic block, which contains `inst`, before `inst` and returns the
+  /// new block.
+  ///
+  /// `inst` and all subsequent instructions are moved to the new block, while all
+  /// instructions _before_ `inst` remain in the original block.
+  func splitBlock(at inst: Instruction) -> BasicBlock {
+    notifyBranchesChanged()
+    return PassContext_splitBlock(inst.bridged).block
+  }
+
+  enum EraseMode {
+    case onlyInstruction, includingDebugUses
+  }
+
+  func erase(instruction: Instruction, _ mode: EraseMode = .onlyInstruction) {
+    switch mode {
+      case .onlyInstruction:
+        break
+      case .includingDebugUses:
+        for result in instruction.results {
+          for use in result.uses {
+            assert(use.instruction is DebugValueInst)
+            PassContext_eraseInstruction(_bridged, use.instruction.bridged)
+          }
+        }
+    }
+
+    if instruction is FullApplySite {
+      notifyCallsChanged()
+    }
+    if instruction is TermInst {
+      notifyBranchesChanged()
+    }
+    notifyInstructionsChanged()
+
+    PassContext_eraseInstruction(_bridged, instruction.bridged)
+  }
+
+  func fixStackNesting(function: Function) {
+    PassContext_fixStackNesting(_bridged, function.bridged)
+  }
+
+  func modifyEffects(in function: Function, _ body: (inout FunctionEffects) -> ()) {
+    function._modifyEffects(body)
+    // TODO: do we need to notify any changes?
+  }
+
+  //===--------------------------------------------------------------------===//
+  //                          Private utilities
+  //===--------------------------------------------------------------------===//
+
+  fileprivate func notifyInstructionsChanged() {
+    PassContext_notifyChanges(_bridged, instructionsChanged)
+  }
+
+  fileprivate func notifyCallsChanged() {
+    PassContext_notifyChanges(_bridged, callsChanged)
+  }
+
+  fileprivate func notifyBranchesChanged() {
+    PassContext_notifyChanges(_bridged, branchesChanged)
+  }
+}
+
+//===----------------------------------------------------------------------===//
+//                          Builder initialization
+//===----------------------------------------------------------------------===//
+
+extension Builder {
+  /// Creates a builder which inserts _before_ `insPnt`, using a custom `location`.
+  init(at insPnt: Instruction, location: Location, _ context: PassContext) {
+    self.init(insertAt: .before(insPnt), location: location, passContext: context._bridged)
+  }
+
+  /// Creates a builder which inserts _before_ `insPnt`, using the location of `insPnt`.
+  init(at insPnt: Instruction, _ context: PassContext) {
+    self.init(insertAt: .before(insPnt), location: insPnt.location, passContext: context._bridged)
+  }
+
+  /// Creates a builder which inserts _after_ `insPnt`, using the location of `insPnt`.
+  init(after insPnt: Instruction, _ context: PassContext) {
+    if let nextInst = insPnt.next {
+      self.init(insertAt: .before(nextInst), location: insPnt.location, passContext: context._bridged)
+    } else {
+      self.init(insertAt: .atEndOf(insPnt.block), location: insPnt.location, passContext: context._bridged)
+    }
+  }
+
+  /// Creates a builder which inserts at the end of `block`, using a custom `location`.
+  init(atEndOf block: BasicBlock, location: Location, _ context: PassContext) {
+    self.init(insertAt: .atEndOf(block), location: location, passContext: context._bridged)
+  }
+
+  /// Creates a builder which inserts at the begin of `block`, using the location of the first
+  /// instruction of `block`.
+  init(atBeginOf block: BasicBlock, _ context: PassContext) {
+    let firstInst = block.instructions.first!
+    self.init(insertAt: .before(firstInst), location: firstInst.location, passContext: context._bridged)
+  }
+}
+
+//===----------------------------------------------------------------------===//
+//                          Modifying the SIL
+//===----------------------------------------------------------------------===//
+
+extension BasicBlock {
+  func addBlockArgument(type: Type, ownership: Ownership, _ context: PassContext) -> BlockArgument {
+    context.notifyInstructionsChanged()
+    return SILBasicBlock_addBlockArgument(bridged, type.bridged, ownership._bridged).blockArgument
+  }
+  
+  func eraseArgument(at index: Int, _ context: PassContext) {
+    context.notifyInstructionsChanged()
+    SILBasicBlock_eraseArgument(bridged, index)
+  }
+}
+
+extension AllocRefInstBase {
+  func setIsStackAllocatable(_ context: PassContext) {
+    context.notifyInstructionsChanged()
+    AllocRefInstBase_setIsStackAllocatable(bridged)
+  }
+}
+
+extension UseList {
+  func replaceAll(with replacement: Value, _ context: PassContext) {
+    for use in self {
+      use.instruction.setOperand(at: use.index, to: replacement, context)
+    }
+  }
+}
+
+extension Instruction {
+  func setOperand(at index : Int, to value: Value, _ context: PassContext) {
+    if self is FullApplySite && index == ApplyOperands.calleeOperandIndex {
+      context.notifyCallsChanged()
+    }
+    context.notifyInstructionsChanged()
+
+    SILInstruction_setOperand(bridged, index, value.bridged)
+  }
+}
+
+extension RefCountingInst {
+  func setAtomicity(isAtomic: Bool, _ context: PassContext) {
+    context.notifyInstructionsChanged()
+    RefCountingInst_setIsAtomic(bridged, isAtomic)
+  }
+}