Merge pull request #64380 from eeckstein/sil-bridging

use C++ interop for SIL bridging

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -17,27 +17,26 @@ struct AliasAnalysis {
   let bridged: BridgedAliasAnalysis
 
   func mayRead(_ inst: Instruction, fromAddress: Value) -> Bool {
-    switch AliasAnalysis_getMemBehavior(bridged, inst.bridged, fromAddress.bridged) {
-      case MayReadBehavior, MayReadWriteBehavior, MayHaveSideEffectsBehavior:
+    switch bridged.getMemBehavior(inst.bridged, fromAddress.bridged) {
+      case .MayRead, .MayReadWrite, .MayHaveSideEffects:
         return true
       default:
         return false
     }
   }
 
   func mayWrite(_ inst: Instruction, toAddress: Value) -> Bool {
-    switch AliasAnalysis_getMemBehavior(bridged, inst.bridged, toAddress.bridged) {
-      case MayWriteBehavior, MayReadWriteBehavior, MayHaveSideEffectsBehavior:
+    switch bridged.getMemBehavior(inst.bridged, toAddress.bridged) {
+      case .MayWrite, .MayReadWrite, .MayHaveSideEffects:
         return true
       default:
         return false
     }
   }
 
   func mayReadOrWrite(_ inst: Instruction, address: Value) -> Bool {
-    switch AliasAnalysis_getMemBehavior(bridged, inst.bridged, address.bridged) {
-      case MayReadBehavior, MayWriteBehavior, MayReadWriteBehavior,
-           MayHaveSideEffectsBehavior:
+    switch bridged.getMemBehavior(inst.bridged, address.bridged) {
+      case .MayRead, .MayWrite, .MayReadWrite, .MayHaveSideEffects:
         return true
       default:
         return false
@@ -62,26 +61,26 @@ struct AliasAnalysis {
   }
 
   static func register() {
-    AliasAnalysis_register(
+    BridgedAliasAnalysis.registerAnalysis(
       // getMemEffectsFn
-      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> BridgedMemoryBehavior in
+      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> swift.MemoryBehavior in
         let context = FunctionPassContext(_bridged: bridgedCtxt)
         let inst = bridgedInst.instruction
         let val = bridgedVal.value
         let path = AliasAnalysis.getPtrOrAddressPath(for: val)
         if let apply = inst as? ApplySite {
           let effect = getMemoryEffect(of: apply, for: val, path: path, context)
           switch (effect.read, effect.write) {
-            case (false, false): return NoneBehavior
-            case (true, false):  return MayReadBehavior
-            case (false, true):  return MayWriteBehavior
-            case (true, true):   return MayReadWriteBehavior
+            case (false, false): return .None
+            case (true, false):  return .MayRead
+            case (false, true):  return .MayWrite
+            case (true, true):   return .MayReadWrite
           }
         }
         if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
-          return MayReadWriteBehavior
+          return .MayReadWrite
         }
-        return NoneBehavior
+        return .None
       },
 
       // isObjReleasedFn

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -17,13 +17,13 @@ public struct CalleeAnalysis {
   let bridged: BridgedCalleeAnalysis
 
   static func register() {
-    CalleeAnalysis_register(
+    BridgedCalleeAnalysis.registerAnalysis(
       // isDeinitBarrierFn:
       { (inst : BridgedInstruction, bca: BridgedCalleeAnalysis) -> Bool in
         return inst.instruction.isDeinitBarrier(bca.analysis)
       },
       // getMemBehaviorFn
-      { (bridgedCtxt: BridgedPassContext, bridgedApply: BridgedInstruction, observeRetains: Bool) -> BridgedMemoryBehavior in
+      { (bridgedCtxt: BridgedPassContext, bridgedApply: BridgedInstruction, observeRetains: Bool) -> swift.MemoryBehavior in
         let context = FunctionPassContext(_bridged: bridgedCtxt)
         let apply = bridgedApply.instruction as! ApplySite
         let e = context.calleeAnalysis.getSideEffects(of: apply)
@@ -33,28 +33,28 @@ public struct CalleeAnalysis {
   }
 
   public func getCallees(callee: Value) -> FunctionArray? {
-    let bridgedFuncs = CalleeAnalysis_getCallees(bridged, callee.bridged)
-    if bridgedFuncs.incomplete != 0 {
+    let bridgedFuncs = bridged.getCallees(callee.bridged)
+    if bridgedFuncs.isIncomplete() {
       return nil
     }
     return FunctionArray(bridged: bridgedFuncs)
   }
 
   public func getIncompleteCallees(callee: Value) -> FunctionArray {
-    return FunctionArray(bridged: CalleeAnalysis_getCallees(bridged, callee.bridged))
+    return FunctionArray(bridged: bridged.getCallees(callee.bridged))
   }
 
   public func getDestructor(ofExactType type: Type) -> Function? {
-    let destructors = FunctionArray(bridged: CalleeAnalysis_getDestructors(bridged, type.bridged, /*isExactType*/ 1))
+    let destructors = FunctionArray(bridged: bridged.getDestructors(type.bridged, /*isExactType*/ true))
     if destructors.count == 1 {
       return destructors[0]
     }
     return nil
   }
 
   public func getDestructors(of type: Type) -> FunctionArray? {
-    let bridgedDtors = CalleeAnalysis_getDestructors(bridged, type.bridged, /*isExactType*/ 0)
-    if bridgedDtors.incomplete != 0 {
+    let bridgedDtors = bridged.getDestructors(type.bridged, /*isExactType*/ false)
+    if bridgedDtors.isIncomplete() {
       return nil
     }
     return FunctionArray(bridged: bridgedDtors)
@@ -123,13 +123,13 @@ extension Instruction {
 }
 
 public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
-  fileprivate let bridged: BridgedCalleeList
+  fileprivate let bridged: swift.CalleeList
 
   public var startIndex: Int { 0 }
-  public var endIndex: Int { BridgedFunctionArray_size(bridged) }
+  public var endIndex: Int { Int(bridged.getCount()) }
 
   public subscript(_ index: Int) -> Function {
-    return BridgedFunctionArray_get(bridged, index).function
+    return BridgedCalleeAnalysis.getCallee(bridged, index).function
   }
 }
 // Bridging utilities

SwiftCompilerSources/Sources/Optimizer/Analysis/DeadEndBlocksAnalysis.swift

@@ -17,6 +17,6 @@ public struct DeadEndBlocksAnalysis {
   let bridged: BridgedDeadEndBlocksAnalysis
 
   public func isDeadEnd(_ block: BasicBlock) -> Bool {
-    return DeadEndBlocksAnalysis_isDeadEnd(bridged, block.bridged) != 0
+    return bridged.isDeadEnd(block.bridged)
   }
 }

SwiftCompilerSources/Sources/Optimizer/Analysis/DominatorTree.swift

@@ -19,7 +19,7 @@ public struct DominatorTree {
 
 extension BasicBlock {
   func dominates(_ other: BasicBlock, _ domTree: DominatorTree) -> Bool {
-    DominatorTree_dominates(domTree.bridged, self.bridged, other.bridged) != 0
+    domTree.bridged.dominates(self.bridged, other.bridged)
   }
 
   func strictlyDominates(_ other: BasicBlock, _ domTree: DominatorTree) -> Bool {

SwiftCompilerSources/Sources/Optimizer/Analysis/PostDominatorTree.swift

@@ -19,7 +19,7 @@ public struct PostDominatorTree {
 
 extension BasicBlock {
   func postDominates(_ other: BasicBlock, _ pdomTree: PostDominatorTree) -> Bool {
-    PostDominatorTree_postDominates(pdomTree.bridged, self.bridged, other.bridged) != 0
+    pdomTree.bridged.postDominates(self.bridged, other.bridged)
   }
 
   func strictlyPostDominates(_ other: BasicBlock, _ pdomTree: PostDominatorTree) -> Bool {

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -38,33 +38,33 @@ struct BasicBlockSet : IntrusiveSet {
 
   init(_ context: some Context) {
     self.context = context._bridged
-    self.bridged = PassContext_allocBasicBlockSet(self.context)
+    self.bridged = self.context.allocBasicBlockSet()
   }
 
   func contains(_ block: BasicBlock) -> Bool {
-    BasicBlockSet_contains(bridged, block.bridged) != 0
+    bridged.contains(block.bridged)
   }
 
   /// Returns true if `block` was not contained in the set before inserting.
   @discardableResult
   mutating func insert(_ block: BasicBlock) -> Bool {
-    BasicBlockSet_insert(bridged, block.bridged) != 0
+    bridged.insert(block.bridged)
   }
 
   mutating func erase(_ block: BasicBlock) {
-    BasicBlockSet_erase(bridged, block.bridged)
+    bridged.erase(block.bridged)
   }
 
   var description: String {
-    let function = BasicBlockSet_getFunction(bridged).function
+    let function = bridged.getFunction().function
     let blockNames = function.blocks.enumerated().filter { contains($0.1) }
                                                  .map { "bb\($0.0)"}
     return "{" + blockNames.joined(separator: ", ") + "}"
   }
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
-    PassContext_freeBasicBlockSet(context, bridged)
+    context.freeBasicBlockSet(bridged)
   }
 }
 
@@ -83,25 +83,25 @@ struct ValueSet : IntrusiveSet {
 
   init(_ context: some Context) {
     self.context = context._bridged
-    self.bridged = PassContext_allocNodeSet(self.context)
+    self.bridged = self.context.allocNodeSet()
   }
 
   func contains(_ value: Value) -> Bool {
-    NodeSet_containsValue(bridged, value.bridged) != 0
+    bridged.containsValue(value.bridged)
   }
 
   /// Returns true if `value` was not contained in the set before inserting.
   @discardableResult
   mutating func insert(_ value: Value) -> Bool {
-    NodeSet_insertValue(bridged, value.bridged) != 0
+    bridged.insertValue(value.bridged)
   }
 
   mutating func erase(_ value: Value) {
-    NodeSet_eraseValue(bridged, value.bridged)
+    bridged.eraseValue(value.bridged)
   }
 
   var description: String {
-    let function = NodeSet_getFunction(bridged).function
+    let function = bridged.getFunction().function
     var d = "{\n"
     for block in function.blocks {
       for arg in block.arguments {
@@ -123,7 +123,7 @@ struct ValueSet : IntrusiveSet {
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
-    PassContext_freeNodeSet(context, bridged)
+    context.freeNodeSet(bridged)
   }
 }
 
@@ -142,25 +142,25 @@ struct InstructionSet : IntrusiveSet {
 
   init(_ context: some Context) {
     self.context = context._bridged
-    self.bridged = PassContext_allocNodeSet(self.context)
+    self.bridged = self.context.allocNodeSet()
   }
 
   func contains(_ inst: Instruction) -> Bool {
-    NodeSet_containsInstruction(bridged, inst.bridged) != 0
+    bridged.containsInstruction(inst.bridged)
   }
 
   /// Returns true if `inst` was not contained in the set before inserting.
   @discardableResult
   mutating func insert(_ inst: Instruction) -> Bool {
-    NodeSet_insertInstruction(bridged, inst.bridged) != 0
+    bridged.insertInstruction(inst.bridged)
   }
 
   mutating func erase(_ inst: Instruction) {
-    NodeSet_eraseInstruction(bridged, inst.bridged)
+    bridged.eraseInstruction(inst.bridged)
   }
 
   var description: String {
-    let function = NodeSet_getFunction(bridged).function
+    let function = bridged.getFunction().function
     var d = "{\n"
     for inst in function.instructions {
       if contains(inst) {
@@ -173,6 +173,6 @@ struct InstructionSet : IntrusiveSet {
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
-    PassContext_freeNodeSet(context, bridged)
+    context.freeNodeSet(bridged)
   }
 }

SwiftCompilerSources/Sources/Optimizer/DataStructures/Stack.swift

@@ -27,22 +27,22 @@ import SIL
 struct Stack<Element> : CollectionLikeSequence {
 
   private let bridgedContext: BridgedPassContext
-  private var firstSlab = BridgedSlab(data: nil)
-  private var lastSlab = BridgedSlab(data: nil)
+  private var firstSlab = BridgedPassContext.Slab(nil)
+  private var lastSlab = BridgedPassContext.Slab(nil)
   private var endIndex: Int = 0
 
   private static var slabCapacity: Int {
-    BridgedSlabCapacity / MemoryLayout<Element>.stride
+    BridgedPassContext.Slab.getCapacity() / MemoryLayout<Element>.stride
   }
 
-  private static func bind(_ slab: BridgedSlab) -> UnsafeMutablePointer<Element> {
-    return slab.data!.bindMemory(to: Element.self, capacity: Stack.slabCapacity)
+  private static func bind(_ slab: BridgedPassContext.Slab) -> UnsafeMutablePointer<Element> {
+    return UnsafeMutableRawPointer(slab.data!).bindMemory(to: Element.self, capacity: Stack.slabCapacity)
   }
 
   struct Iterator : IteratorProtocol {
-    var slab: BridgedSlab
+    var slab: BridgedPassContext.Slab
     var index: Int
-    let lastSlab: BridgedSlab
+    let lastSlab: BridgedPassContext.Slab
     let endIndex: Int
 
     mutating func next() -> Element? {
@@ -52,7 +52,7 @@ struct Stack<Element> : CollectionLikeSequence {
         index += 1
 
         if index >= end && slab.data != lastSlab.data {
-          slab = PassContext_getNextSlab(slab)
+          slab = slab.getNext()
           index = 0
         }
         return elem
@@ -77,11 +77,11 @@ struct Stack<Element> : CollectionLikeSequence {
 
   mutating func push(_ element: Element) {
     if endIndex >= Stack.slabCapacity {
-      lastSlab = PassContext_allocSlab(bridgedContext, lastSlab)
+      lastSlab = bridgedContext.allocSlab(lastSlab)
       endIndex = 0
     } else if firstSlab.data == nil {
       assert(endIndex == 0)
-      firstSlab = PassContext_allocSlab(bridgedContext, lastSlab)
+      firstSlab = bridgedContext.allocSlab(lastSlab)
       lastSlab = firstSlab
     }
     (Stack.bind(lastSlab) + endIndex).initialize(to: element)
@@ -109,12 +109,12 @@ struct Stack<Element> : CollectionLikeSequence {
 
     if endIndex == 0 {
       if lastSlab.data == firstSlab.data {
-        _ = PassContext_freeSlab(bridgedContext, lastSlab)
+        _ = bridgedContext.freeSlab(lastSlab)
         firstSlab.data = nil
         lastSlab.data = nil
         endIndex = 0
       } else {
-        lastSlab = PassContext_freeSlab(bridgedContext, lastSlab)
+        lastSlab = bridgedContext.freeSlab(lastSlab)
         endIndex = Stack.slabCapacity
       }
     }