Swift Bridging: use C++ instead of C bridging for BridgedOperand and BridgedValue

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -217,7 +217,7 @@ extension Builder {
 
 extension Undef {
   static func get(type: Type, _ context: some MutatingContext) -> Undef {
-    SILUndef_get(type.bridged, context._bridged).getAs(Undef.self)
+    SILUndef_get(type.bridged, context._bridged).value as! Undef
   }
 }
 

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -43,7 +43,8 @@ public class Instruction : CustomStringConvertible, Hashable {
   }
 
   final public var operands: OperandArray {
-    return OperandArray(opArray: SILInstruction_getOperands(bridged))
+    let operands = SILInstruction_getOperands(bridged)
+    return OperandArray(base: operands.base, count: operands.count)
   }
 
   fileprivate var resultCount: Int { 0 }

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -16,49 +16,48 @@ import SILBridging
 public struct Operand : CustomStringConvertible, NoReflectionChildren {
   fileprivate let bridged: BridgedOperand
 
-  init(_ bridged: BridgedOperand) {
+  init(bridged: BridgedOperand) {
     self.bridged = bridged
   }
 
-  public var value: Value {
-    Operand_getValue(bridged).value
-  }
+  public var value: Value { bridged.getValue().value }
 
   public static func ==(lhs: Operand, rhs: Operand) -> Bool {
     return lhs.bridged.op == rhs.bridged.op
   }
 
   public var instruction: Instruction {
-    return Operand_getUser(bridged).instruction
+    return bridged.getUser().instruction
   }
 
   public var index: Int { instruction.operands.getIndex(of: self) }
 
   /// True if the operand is used to describe a type dependency, but it's not
   /// used as value.
-  public var isTypeDependent: Bool { Operand_isTypeDependent(bridged) != 0 }
+  public var isTypeDependent: Bool { bridged.isTypeDependent() }
 
   public var description: String { "operand #\(index) of \(instruction)" }
 }
 
 public struct OperandArray : RandomAccessCollection, CustomReflectable {
-  private let opArray: BridgedArrayRef
+  private let base: OptionalBridgedOperand
+  public let count: Int
 
-  init(opArray: BridgedArrayRef) {
-    self.opArray = opArray
+  init(base: OptionalBridgedOperand, count: Int) {
+    self.base = base
+    self.count = count
   }
-  
+
   public var startIndex: Int { return 0 }
-  public var endIndex: Int { return Int(opArray.numElements) }
+  public var endIndex: Int { return count }
 
   public subscript(_ index: Int) -> Operand {
-    assert(index >= 0 && index < endIndex)
-    return Operand(BridgedOperand(op: opArray.data! + index &* BridgedOperandSize))
+    assert(index >= startIndex && index < endIndex)
+    return Operand(bridged: base.advancedBy(index))
   }
 
   public func getIndex(of operand: Operand) -> Int {
-    let idx = (operand.bridged.op - UnsafeRawPointer(opArray.data!)) /
-                BridgedOperandSize
+    let idx = base.distanceTo(operand.bridged)
     assert(self[idx].bridged.op == operand.bridged.op)
     return idx
   }
@@ -72,38 +71,38 @@ public struct OperandArray : RandomAccessCollection, CustomReflectable {
   ///
   /// Note: this does not return a Slice. The first index of the returnd array is always 0.
   public subscript(bounds: Range<Int>) -> OperandArray {
-    assert(bounds.lowerBound >= 0)
-    assert(bounds.upperBound <= endIndex)
-    return OperandArray(opArray: BridgedArrayRef(
-      data: opArray.data! + bounds.lowerBound &* BridgedOperandSize,
-      numElements: bounds.upperBound - bounds.lowerBound))
+    assert(bounds.lowerBound >= startIndex && bounds.upperBound <= endIndex)
+    return OperandArray(
+      base: OptionalBridgedOperand(op: base.advancedBy(bounds.lowerBound).op),
+      count: bounds.upperBound - bounds.lowerBound)
   }
 }
 
 public struct UseList : CollectionLikeSequence {
   public struct Iterator : IteratorProtocol {
-    var currentOpPtr: UnsafeRawPointer?
+    var currentOpPtr: OptionalBridgedOperand
 
     public mutating func next() -> Operand? {
-      if let opPtr = currentOpPtr {
-        let bridged = BridgedOperand(op: opPtr)
-        currentOpPtr = Operand_nextUse(bridged).op
-        return Operand(bridged)
+      if let op = currentOpPtr.operand {
+        currentOpPtr = op.getNextUse()
+        return Operand(bridged: op)
       }
       return nil
     }
   }
 
-  private let firstOpPtr: UnsafeRawPointer?
+  private let firstOpPtr: OptionalBridgedOperand
 
   init(_ firstOpPtr: OptionalBridgedOperand) {
-    self.firstOpPtr = firstOpPtr.op
+    self.firstOpPtr = firstOpPtr
   }
 
   public var singleUse: Operand? {
-    if let opPtr = firstOpPtr {
-      if Operand_nextUse(BridgedOperand(op: opPtr)).op != nil { return nil }
-      return Operand(BridgedOperand(op: opPtr))
+    if let op = firstOpPtr.operand {
+      if op.getNextUse().operand != nil {
+        return nil
+      }
+      return Operand(bridged: op)
     }
     return nil
   }
@@ -114,3 +113,12 @@ public struct UseList : CollectionLikeSequence {
     return Iterator(currentOpPtr: firstOpPtr)
   }
 }
+
+extension OptionalBridgedOperand {
+  var operand: BridgedOperand? {
+    if let op = op {
+      return BridgedOperand(op: op)
+    }
+    return nil
+  }
+}

SwiftCompilerSources/Sources/SIL/Utils.swift

@@ -189,9 +189,11 @@ public struct ParsingError : Error {
 
 extension Array where Element == Value {
   public func withBridgedValues<T>(_ c: (BridgedValueArray) -> T) -> T {
-    return self.withUnsafeBytes { valPtr in
-      assert(valPtr.count == self.count * 16)
-      return c(BridgedValueArray(data: valPtr.baseAddress, count: self.count))
+    return self.withUnsafeBufferPointer { bufPtr in
+      assert(bufPtr.count == self.count)
+      return bufPtr.withMemoryRebound(to: BridgeValueExistential.self) { valPtr in
+        return c(BridgedValueArray(base: valPtr.baseAddress, count: self.count))
+      }
     }
   }
 }

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -76,12 +76,12 @@ public enum Ownership {
   /// statically available on some control flow paths.
   case none
 
-  public var _bridged: BridgedOwnership {
+  public var _bridged: BridgedValue.Ownership {
     switch self {
-      case .unowned:    return Ownership_Unowned
-      case .owned:      return Ownership_Owned
-      case .guaranteed: return Ownership_Guaranteed
-      case .none:       return Ownership_None
+      case .unowned:    return BridgedValue.Ownership.Unowned
+      case .owned:      return BridgedValue.Ownership.Owned
+      case .guaranteed: return BridgedValue.Ownership.Guaranteed
+      case .none:       return BridgedValue.Ownership.None
     }
   }
 }
@@ -92,21 +92,19 @@ extension Value {
     return String(_cxxString: stdString)
   }
 
-  public var uses: UseList {
-    UseList(SILValue_firstUse(bridged))
-  }
+  public var uses: UseList { UseList(bridged.getFirstUse()) }
 
   public var parentFunction: Function { parentBlock.parentFunction }
 
-  public var type: Type { SILValue_getType(bridged).type }
+  public var type: Type { bridged.getType().type }
 
   /// True if the value has a trivial type.
   public var hasTrivialType: Bool { type.isTrivial(in: parentFunction) }
 
   /// 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 { SILValue_getOwnership(bridged).ownership }
+  public var ownership: Ownership { bridged.getOwnership().ownership }
 
   public var hashable: HashableValue { ObjectIdentifier(self) }
 
@@ -156,15 +154,10 @@ extension Value {
 
 
 extension BridgedValue {
-  public func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }
-
-  public var value: Value { getAs(AnyObject.self) as! Value }
-}
-
-extension BridgedClassifiedValue {
   public var value: Value {
     // Doing the type check in C++ is much faster than a conformance lookup with `as! Value`.
-    switch kind {
+    // And it makes a difference because this is a time critical function.
+    switch getKind() {
       case .SingleValueInstruction:
         return obj.getAs(SingleValueInstruction.self)
       case .Argument:
@@ -206,13 +199,13 @@ extension OptionalBridgedValue {
   var value: Value? { obj.getAs(AnyObject.self) as? Value }
 }
 
-extension BridgedOwnership {
+extension BridgedValue.Ownership {
   var ownership: Ownership {
     switch self {
-      case Ownership_Unowned:    return .unowned
-      case Ownership_Owned:      return .owned
-      case Ownership_Guaranteed: return .guaranteed
-      case Ownership_None:       return .none
+      case .Unowned:    return .unowned
+      case .Owned:      return .owned
+      case .Guaranteed: return .guaranteed
+      case .None:       return .none
       default:
         fatalError("unsupported ownership")
     }