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

Author: eeckstein

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -143,19 +143,20 @@ public struct ArgumentArray : RandomAccessCollection {
 }
 
 public struct SuccessorArray : RandomAccessCollection, FormattedLikeArray {
-  private let succArray: BridgedArrayRef
+  private let base: OptionalBridgedSuccessor
+  public let count: Int
 
-  init(succArray: BridgedArrayRef) {
-    self.succArray = succArray
+  init(base: OptionalBridgedSuccessor, count: Int) {
+    self.base = base
+    self.count = count
   }
 
   public var startIndex: Int { return 0 }
-  public var endIndex: Int { return Int(succArray.numElements) }
+  public var endIndex: Int { return count }
 
   public subscript(_ index: Int) -> BasicBlock {
-    assert(index >= 0 && index < endIndex)
-    let s = BridgedSuccessor(succ: succArray.data! + index &* BridgedSuccessorSize);
-    return SILSuccessor_getTargetBlock(s).block
+    assert(index >= startIndex && index < endIndex)
+    return base.advancedBy(index).getTargetBlock().block
   }
 }
 
@@ -165,10 +166,9 @@ public struct PredecessorList : CollectionLikeSequence, IteratorProtocol {
   public init(startAt: OptionalBridgedSuccessor) { currentSucc = startAt }
 
   public mutating func next() -> BasicBlock? {
-    if let succPtr = currentSucc.succ {
-      let succ = BridgedSuccessor(succ: succPtr)
-      currentSucc = SILSuccessor_getNext(succ)
-      return SILSuccessor_getContainingInst(succ).instruction.parentBlock
+    if let succ = currentSucc.successor {
+      currentSucc = succ.getNext()
+      return succ.getContainingInst().instruction.parentBlock
     }
     return nil
   }
@@ -196,3 +196,12 @@ extension Optional where Wrapped == BasicBlock {
     OptionalBridgedBasicBlock(obj: self?.bridged.obj)
   }
 }
+
+extension OptionalBridgedSuccessor {
+  var successor: BridgedSuccessor? {
+    if let succ = succ {
+      return BridgedSuccessor(succ: succ)
+    }
+    return nil
+  }
+}

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -779,7 +779,8 @@ final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {
 
 public class TermInst : Instruction {
   final public var successors: SuccessorArray {
-    SuccessorArray(succArray: TermInst_getSuccessors(bridged))
+    let succArray = TermInst_getSuccessors(bridged)
+    return SuccessorArray(base: succArray.base, count: succArray.count)
   }
 
   public var isFunctionExiting: Bool { false }

include/swift/SIL/SILBridging.h

@@ -28,9 +28,9 @@ SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 struct BridgedInstruction;
 struct OptionalBridgedOperand;
+struct OptionalBridgedSuccessor;
 
 enum {
-  BridgedSuccessorSize = 4 * sizeof(uintptr_t) + sizeof(uint64_t),
   BridgedVTableEntrySize = 5 * sizeof(uintptr_t),
   BridgedWitnessTableEntrySize = 5 * sizeof(uintptr_t)
 };
@@ -133,14 +133,6 @@ struct BridgedOperandArray {
   SwiftInt count;
 };
 
-typedef struct {
-  const void * _Nonnull succ;
-} BridgedSuccessor;
-
-typedef struct {
-  const void * _Nullable succ;
-} OptionalBridgedSuccessor;
-
 typedef struct {
   const void * _Nonnull ptr;
 } BridgedVTable;
@@ -181,9 +173,37 @@ typedef struct {
   SwiftObject obj;
 } BridgedGlobalVar;
 
-typedef struct {
+struct BridgedBasicBlock {
   SwiftObject obj;
-} BridgedBasicBlock;
+};
+
+struct BridgedSuccessor {
+  const swift::SILSuccessor * _Nonnull succ;
+
+  SWIFT_IMPORT_UNSAFE
+  inline OptionalBridgedSuccessor getNext() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedBasicBlock getTargetBlock() const {
+    return {succ->getBB()};
+  }
+
+  SWIFT_IMPORT_UNSAFE
+  inline BridgedInstruction getContainingInst() const;
+};
+
+struct OptionalBridgedSuccessor {
+  const swift::SILSuccessor * _Nullable succ;
+
+  // Assumes that `succ` is not null.
+  SWIFT_IMPORT_UNSAFE
+  BridgedSuccessor advancedBy(SwiftInt index) const { return {succ + index}; }
+};
+
+struct BridgedSuccessorArray {
+  OptionalBridgedSuccessor base;
+  SwiftInt count;
+};
 
 typedef struct {
   OptionalSwiftObject obj;
@@ -362,9 +382,6 @@ void SILBasicBlock_moveAllInstructionsToBegin(BridgedBasicBlock block, BridgedBa
 void SILBasicBlock_moveAllInstructionsToEnd(BridgedBasicBlock block, BridgedBasicBlock dest);
 void BasicBlock_moveArgumentsTo(BridgedBasicBlock block, BridgedBasicBlock dest);
 OptionalBridgedSuccessor SILBasicBlock_getFirstPred(BridgedBasicBlock block);
-OptionalBridgedSuccessor SILSuccessor_getNext(BridgedSuccessor succ);
-BridgedBasicBlock SILSuccessor_getTargetBlock(BridgedSuccessor succ);
-BridgedInstruction SILSuccessor_getContainingInst(BridgedSuccessor succ);
 
 std::string SILNode_debugDescription(BridgedNode node);
 
@@ -428,7 +445,7 @@ SwiftInt MultipleValueInstruction_getNumResults(BridgedInstruction inst);
 BridgedMultiValueResult
   MultipleValueInstruction_getResult(BridgedInstruction inst, SwiftInt index);
 
-BridgedArrayRef TermInst_getSuccessors(BridgedInstruction term);
+BridgedSuccessorArray TermInst_getSuccessors(BridgedInstruction term);
 
 llvm::StringRef CondFailInst_getMessage(BridgedInstruction cfi);
 SwiftInt LoadInst_getLoadOwnership(BridgedInstruction load);
@@ -547,6 +564,14 @@ OptionalBridgedOperand BridgedValue::getFirstUse() const {
   return {*getSILValue()->use_begin()};
 }
 
+OptionalBridgedSuccessor BridgedSuccessor::getNext() const {
+  return {succ->getNext()};
+}
+
+BridgedInstruction BridgedSuccessor::getContainingInst() const {
+  return {succ->getContainingInst()};
+}
+
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 

lib/SIL/Utils/SILBridging.cpp

@@ -293,9 +293,6 @@ void SILFunction_setNeedStackProtection(BridgedFunction function,
 //                               SILBasicBlock
 //===----------------------------------------------------------------------===//
 
-static_assert(BridgedSuccessorSize == sizeof(SILSuccessor),
-              "wrong bridged SILSuccessor size");
-
 OptionalBridgedBasicBlock SILBasicBlock_next(BridgedBasicBlock block) {
   SILBasicBlock *b = castToBasicBlock(block);
   auto iter = std::next(b->getIterator());
@@ -373,22 +370,6 @@ OptionalBridgedSuccessor SILBasicBlock_getFirstPred(BridgedBasicBlock block) {
   return {castToBasicBlock(block)->pred_begin().getSuccessorRef()};
 }
 
-static SILSuccessor *castToSuccessor(BridgedSuccessor succ) {
-  return const_cast<SILSuccessor *>(static_cast<const SILSuccessor *>(succ.succ));
-}
-
-OptionalBridgedSuccessor SILSuccessor_getNext(BridgedSuccessor succ) {
-  return {castToSuccessor(succ)->getNext()};
-}
-
-BridgedBasicBlock SILSuccessor_getTargetBlock(BridgedSuccessor succ) {
-  return {castToSuccessor(succ)->getBB()};
-}
-
-BridgedInstruction SILSuccessor_getContainingInst(BridgedSuccessor succ) {
-  return {castToSuccessor(succ)->getContainingInst()};
-}
-
 //===----------------------------------------------------------------------===//
 //                                SILArgument
 //===----------------------------------------------------------------------===//
@@ -885,9 +866,9 @@ MultipleValueInstruction_getResult(BridgedInstruction inst, SwiftInt index) {
   return {castToInst<MultipleValueInstruction>(inst)->getResult(index)};
 }
 
-BridgedArrayRef TermInst_getSuccessors(BridgedInstruction term) {
+BridgedSuccessorArray TermInst_getSuccessors(BridgedInstruction term) {
   auto successors = castToInst<TermInst>(term)->getSuccessors();
-  return {(const unsigned char *)successors.data(), successors.size()};
+  return {{successors.data()}, (SwiftInt)successors.size()};
 }
 
 //===----------------------------------------------------------------------===//