Swift Bridging: use C++ instead of C bridging for BridgedBasicBlock

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -224,24 +224,24 @@ extension Undef {
 extension BasicBlock {
   func addBlockArgument(type: Type, ownership: Ownership, _ context: some MutatingContext) -> BlockArgument {
     context.notifyInstructionsChanged()
-    return SILBasicBlock_addBlockArgument(bridged, type.bridged, ownership._bridged).blockArgument
+    return bridged.addBlockArgument(type.bridged, ownership._bridged).blockArgument
   }
 
   func eraseArgument(at index: Int, _ context: some MutatingContext) {
     context.notifyInstructionsChanged()
-    SILBasicBlock_eraseArgument(bridged, index)
+    bridged.eraseArgument(index)
   }
 
   func moveAllInstructions(toBeginOf otherBlock: BasicBlock, _ context: some MutatingContext) {
     context.notifyInstructionsChanged()
     context.notifyBranchesChanged()
-    SILBasicBlock_moveAllInstructionsToBegin(bridged, otherBlock.bridged)
+    bridged.moveAllInstructionsToBegin(otherBlock.bridged)
   }
 
   func moveAllInstructions(toEndOf otherBlock: BasicBlock, _ context: some MutatingContext) {
     context.notifyInstructionsChanged()
     context.notifyBranchesChanged()
-    SILBasicBlock_moveAllInstructionsToEnd(bridged, otherBlock.bridged)
+    bridged.moveAllInstructionsToEnd(otherBlock.bridged)
   }
 
   func eraseAllArguments(_ context: some MutatingContext) {
@@ -252,7 +252,7 @@ extension BasicBlock {
   }
 
   func moveAllArguments(to otherBlock: BasicBlock, _ context: some MutatingContext) {
-    BasicBlock_moveArgumentsTo(bridged, otherBlock.bridged)
+    bridged.moveArgumentsTo(otherBlock.bridged)
   }
 }
 

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -15,31 +15,31 @@ import SILBridging
 
 @_semantics("arc.immortal")
 final public class BasicBlock : CustomStringConvertible, HasShortDescription {
-  public var next: BasicBlock? { SILBasicBlock_next(bridged).block }
-  public var previous: BasicBlock? { SILBasicBlock_previous(bridged).block }
+  public var next: BasicBlock? { bridged.getNext().block }
+  public var previous: BasicBlock? { bridged.getPrevious().block }
 
-  public var parentFunction: Function { SILBasicBlock_getFunction(bridged).function }
+  public var parentFunction: Function { bridged.getFunction().function }
 
   public var description: String {
-    let stdString = SILBasicBlock_debugDescription(bridged)
+    let stdString = bridged.getDebugDescription()
     return String(_cxxString: stdString)
   }
   public var shortDescription: String { name }
 
   public var arguments: ArgumentArray { ArgumentArray(block: self) }
 
   public var instructions: InstructionList {
-    InstructionList(first: SILBasicBlock_firstInst(bridged).instruction)
+    InstructionList(first: bridged.getFirstInst().instruction)
   }
 
   public var terminator: TermInst {
-    SILBasicBlock_lastInst(bridged).instruction as! TermInst
+    bridged.getLastInst().instruction as! TermInst
   }
 
   public var successors: SuccessorArray { terminator.successors }
 
   public var predecessors: PredecessorList {
-    PredecessorList(startAt: SILBasicBlock_getFirstPred(bridged))
+    PredecessorList(startAt: bridged.getFirstPred())
   }
 
   public var singlePredecessor: BasicBlock? {
@@ -98,7 +98,7 @@ public struct InstructionList : CollectionLikeSequence, IteratorProtocol {
 
   public func reversed() -> ReverseInstructionList {
     if let inst = currentInstruction {
-      let lastInst = SILBasicBlock_lastInst(inst.parentBlock.bridged).instruction
+      let lastInst = inst.parentBlock.bridged.getLastInst().instruction
       return ReverseInstructionList(first: lastInst)
     }
     return ReverseInstructionList(first: nil)
@@ -135,10 +135,10 @@ public struct ArgumentArray : RandomAccessCollection {
   fileprivate let block: BasicBlock
 
   public var startIndex: Int { return 0 }
-  public var endIndex: Int { SILBasicBlock_getNumArguments(block.bridged) }
+  public var endIndex: Int { block.bridged.getNumArguments() }
 
   public subscript(_ index: Int) -> Argument {
-    SILBasicBlock_getArgument(block.bridged, index).argument
+    block.bridged.getArgument(index).argument
   }
 }
 

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -104,7 +104,16 @@ extension Value {
   /// True if the value has a trivial type which is and does not contain a Builtin.RawPointer.
   public var hasTrivialNonPointerType: Bool { type.isTrivialNonPointer(in: parentFunction) }
 
-  public var ownership: Ownership { bridged.getOwnership().ownership }
+  public var ownership: Ownership {
+    switch bridged.getOwnership() {
+    case .Unowned:    return .unowned
+    case .Owned:      return .owned
+    case .Guaranteed: return .guaranteed
+    case .None:       return .none
+    default:
+      fatalError("unsupported ownership")
+    }
+  }
 
   public var hashable: HashableValue { ObjectIdentifier(self) }
 
@@ -198,16 +207,3 @@ final class PlaceholderValue : Value {
 extension OptionalBridgedValue {
   var value: Value? { obj.getAs(AnyObject.self) as? Value }
 }
-
-extension BridgedValue.Ownership {
-  var ownership: Ownership {
-    switch self {
-      case .Unowned:    return .unowned
-      case .Owned:      return .owned
-      case .Guaranteed: return .guaranteed
-      case .None:       return .none
-      default:
-        fatalError("unsupported ownership")
-    }
-  }
-}

include/swift/SIL/SILBridging.h

@@ -88,6 +88,19 @@ struct BridgedValue {
   }
 };
 
+struct OptionalBridgedValue {
+  OptionalSwiftObject obj;
+};
+
+inline swift::ValueOwnershipKind castToOwnership(BridgedValue::Ownership ownership) {
+  switch (ownership) {
+    case BridgedValue::Ownership::Unowned:    return swift::OwnershipKind::Unowned;
+    case BridgedValue::Ownership::Owned:      return swift::OwnershipKind::Owned;
+    case BridgedValue::Ownership::Guaranteed: return swift::OwnershipKind::Guaranteed;
+    case BridgedValue::Ownership::None:       return swift::OwnershipKind::None;
+  }
+}
+
 // This is the layout of a class existential.
 struct BridgeValueExistential {
   BridgedValue value;
@@ -301,8 +314,106 @@ struct BridgedGlobalVar {
   bool isLet() const { return getGlobal()->isLet(); }
 };
 
+struct BridgedInstruction {
+  SwiftObject obj;
+};
+
+typedef struct {
+  OptionalSwiftObject obj;
+} OptionalBridgedInstruction;
+
+typedef struct {
+  SwiftObject obj;
+} BridgedArgument;
+
+typedef struct {
+  OptionalSwiftObject obj;
+} OptionalBridgedArgument;
+
+struct OptionalBridgedBasicBlock {
+  OptionalSwiftObject obj;
+
+  swift::SILBasicBlock *getBlock() const {
+    return obj ? static_cast<swift::SILBasicBlock *>(obj) : nullptr;
+  }
+};
+
 struct BridgedBasicBlock {
   SwiftObject obj;
+
+  swift::SILBasicBlock * _Nonnull getBlock() const {
+    return static_cast<swift::SILBasicBlock *>(obj);
+  }
+
+  std::string getDebugDescription() const;
+
+  SWIFT_IMPORT_UNSAFE
+  OptionalBridgedBasicBlock getNext() const {
+    auto iter = std::next(getBlock()->getIterator());
+    if (iter == getBlock()->getParent()->end())
+      return {nullptr};
+    return {&*iter};
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  OptionalBridgedBasicBlock getPrevious() const {
+    auto iter = std::next(getBlock()->getReverseIterator());
+    if (iter == getBlock()->getParent()->rend())
+      return {nullptr};
+    return {&*iter};
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedFunction getFunction() const {
+    return {getBlock()->getParent()};
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  OptionalBridgedInstruction getFirstInst() const {
+    if (getBlock()->empty())
+      return {nullptr};
+    return {getBlock()->front().asSILNode()};
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  OptionalBridgedInstruction getLastInst() const {
+    if (getBlock()->empty())
+      return {nullptr};
+    return {getBlock()->back().asSILNode()};
+  }
+
+  SwiftInt getNumArguments() const {
+    return getBlock()->getNumArguments();
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedArgument getArgument(SwiftInt index) const {
+    return {getBlock()->getArgument(index)};
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedArgument addBlockArgument(swift::SILType type, BridgedValue::Ownership ownership) const {
+    return {getBlock()->createPhiArgument(type, castToOwnership(ownership))};
+  }
+
+  void eraseArgument(SwiftInt index) const {
+    getBlock()->eraseArgument(index);
+  }
+
+  void moveAllInstructionsToBegin(BridgedBasicBlock dest) const {
+    dest.getBlock()->spliceAtBegin(getBlock());
+  }
+
+  void moveAllInstructionsToEnd(BridgedBasicBlock dest) const {
+    dest.getBlock()->spliceAtEnd(getBlock());
+  }
+
+  void moveArgumentsTo(BridgedBasicBlock dest) const {
+    dest.getBlock()->moveArgumentList(getBlock());
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  inline OptionalBridgedSuccessor getFirstPred() const;
 };
 
 struct BridgedSuccessor {
@@ -333,34 +444,10 @@ struct BridgedSuccessorArray {
   SwiftInt count;
 };
 
-struct OptionalBridgedBasicBlock {
-  OptionalSwiftObject obj;
-};
-
-typedef struct {
-  SwiftObject obj;
-} BridgedArgument;
-
-typedef struct {
-  OptionalSwiftObject obj;
-} OptionalBridgedArgument;
-
 typedef struct {
   SwiftObject obj;
 } BridgedNode;
 
-typedef struct {
-  OptionalSwiftObject obj;
-} OptionalBridgedValue;
-
-struct BridgedInstruction {
-  SwiftObject obj;
-};
-
-typedef struct {
-  OptionalSwiftObject obj;
-} OptionalBridgedInstruction;
-
 typedef struct {
   SwiftObject obj;
 } BridgedMultiValueResult;
@@ -470,23 +557,6 @@ void PassContext_eraseInstruction(BridgedPassContext passContext,
 void PassContext_eraseBlock(BridgedPassContext passContext,
                             BridgedBasicBlock block);
 
-OptionalBridgedBasicBlock SILBasicBlock_next(BridgedBasicBlock block);
-OptionalBridgedBasicBlock SILBasicBlock_previous(BridgedBasicBlock block);
-BridgedFunction SILBasicBlock_getFunction(BridgedBasicBlock block);
-std::string SILBasicBlock_debugDescription(BridgedBasicBlock block);
-OptionalBridgedInstruction SILBasicBlock_firstInst(BridgedBasicBlock block);
-OptionalBridgedInstruction SILBasicBlock_lastInst(BridgedBasicBlock block);
-SwiftInt SILBasicBlock_getNumArguments(BridgedBasicBlock block);
-BridgedArgument SILBasicBlock_getArgument(BridgedBasicBlock block, SwiftInt index);
-BridgedArgument SILBasicBlock_addBlockArgument(BridgedBasicBlock block,
-                                               swift::SILType type,
-                                               BridgedValue::Ownership ownership);
-void SILBasicBlock_eraseArgument(BridgedBasicBlock block, SwiftInt index);
-void SILBasicBlock_moveAllInstructionsToBegin(BridgedBasicBlock block, BridgedBasicBlock dest);
-void SILBasicBlock_moveAllInstructionsToEnd(BridgedBasicBlock block, BridgedBasicBlock dest);
-void BasicBlock_moveArgumentsTo(BridgedBasicBlock block, BridgedBasicBlock dest);
-OptionalBridgedSuccessor SILBasicBlock_getFirstPred(BridgedBasicBlock block);
-
 std::string SILNode_debugDescription(BridgedNode node);
 
 std::string SILLocation_debugDescription(swift::SILDebugLocation loc);
@@ -654,6 +724,9 @@ OptionalBridgedBasicBlock BridgedFunction::getLastBlock() const {
   return {getFunction()->empty() ? nullptr : &*getFunction()->rbegin()};
 }
 
+OptionalBridgedSuccessor BridgedBasicBlock::getFirstPred() const {
+  return {getBlock()->pred_begin().getSuccessorRef()};
+}
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 

include/swift/SIL/SILBridgingUtils.h

@@ -39,27 +39,10 @@ template <class I = SILInstruction> I *castToInst(OptionalBridgedInstruction ins
   return cast<I>(static_cast<SILNode *>(inst.obj)->castToInstruction());
 }
 
-inline SILBasicBlock *castToBasicBlock(BridgedBasicBlock block) {
-  return static_cast<SILBasicBlock *>(block.obj);
-}
-
-inline SILBasicBlock *castToBasicBlock(OptionalBridgedBasicBlock block) {
-  return block.obj ? static_cast<SILBasicBlock *>(block.obj) : nullptr;
-}
-
 template <class A = SILArgument> A *castToArgument(BridgedArgument argument) {
   return cast<A>(static_cast<SILArgument *>(argument.obj));
 }
 
-inline ValueOwnershipKind castToOwnership(BridgedValue::Ownership ownership) {
-  switch (ownership) {
-    case BridgedValue::Ownership::Unowned:    return OwnershipKind::Unowned;
-    case BridgedValue::Ownership::Owned:      return OwnershipKind::Owned;
-    case BridgedValue::Ownership::Guaranteed: return OwnershipKind::Guaranteed;
-    case BridgedValue::Ownership::None:       return OwnershipKind::None;
-  }
-}
-
 ArrayRef<SILValue> getSILValues(BridgedValueArray values,
                                 SmallVectorImpl<SILValue> &storage);