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

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -301,7 +301,7 @@ extension TermInst {
 extension Function {
   func set(needStackProtection: Bool, _ context: FunctionPassContext) {
     context.notifyEffectsChanged()
-    SILFunction_setNeedStackProtection(bridged, needStackProtection ? 1 : 0)
+    bridged.setNeedStackProtection(needStackProtection)
   }
 
   func fixStackNesting(_ context: FunctionPassContext) {

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -193,17 +193,17 @@ extension BridgedArgument {
   public var functionArgument: FunctionArgument { obj.getAs(FunctionArgument.self) }
 }
 
-extension BridgedArgumentConvention {
+extension BridgedFunction.ArgumentConvention {
   var convention: ArgumentConvention {
     switch self {
-      case ArgumentConvention_Indirect_In:             return .indirectIn
-      case ArgumentConvention_Indirect_In_Guaranteed:  return .indirectInGuaranteed
-      case ArgumentConvention_Indirect_Inout:          return .indirectInout
-      case ArgumentConvention_Indirect_InoutAliasable: return .indirectInoutAliasable
-      case ArgumentConvention_Indirect_Out:            return .indirectOut
-      case ArgumentConvention_Direct_Owned:            return .directOwned
-      case ArgumentConvention_Direct_Unowned:          return .directUnowned
-      case ArgumentConvention_Direct_Guaranteed:       return .directGuaranteed
+      case .Indirect_In:             return .indirectIn
+      case .Indirect_In_Guaranteed:  return .indirectInGuaranteed
+      case .Indirect_Inout:          return .indirectInout
+      case .Indirect_InoutAliasable: return .indirectInoutAliasable
+      case .Indirect_Out:            return .indirectOut
+      case .Direct_Owned:            return .directOwned
+      case .Direct_Unowned:          return .directUnowned
+      case .Direct_Guaranteed:       return .directGuaranteed
       default:
         fatalError("unsupported argument convention")
     }

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -18,11 +18,11 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   public private(set) var effects = FunctionEffects()
 
   public var name: StringRef {
-    return StringRef(bridged: SILFunction_getName(bridged))
+    return StringRef(bridged: bridged.getName())
   }
 
   final public var description: String {
-    let stdString = SILFunction_debugDescription(bridged)
+    let stdString = bridged.getDebugDescription()
     return String(_cxxString: stdString)
   }
 
@@ -32,20 +32,16 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     hasher.combine(ObjectIdentifier(self))
   }
 
-  public var hasOwnership: Bool { SILFunction_hasOwnership(bridged) != 0 }
+  public var hasOwnership: Bool { bridged.hasOwnership() }
 
   /// Returns true if the function is a definition and not only an external declaration.
   ///
   /// This is the case if the functioun contains a body, i.e. some basic blocks.
   public var isDefinition: Bool { blocks.first != nil }
 
-  public var entryBlock: BasicBlock {
-    SILFunction_firstBlock(bridged).block!
-  }
+  public var blocks : BasicBlockList { BasicBlockList(first: bridged.getFirstBlock().block) }
 
-  public var blocks : BasicBlockList {
-    BasicBlockList(first: SILFunction_firstBlock(bridged).block)
-  }
+  public var entryBlock: BasicBlock { blocks.first! }
 
   public var arguments: LazyMapSequence<ArgumentArray, FunctionArgument> {
     entryBlock.arguments.lazy.map { $0 as! FunctionArgument }
@@ -61,14 +57,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   }
 
   /// The number of indirect result arguments.
-  public var numIndirectResultArguments: Int {
-    SILFunction_numIndirectResultArguments(bridged)
-  }
+  public var numIndirectResultArguments: Int { bridged.getNumIndirectFormalResults() }
 
   /// The number of arguments which correspond to parameters (and not to indirect results).
-  public var numParameterArguments: Int {
-    SILFunction_numParameterArguments(bridged)
-  }
+  public var numParameterArguments: Int { bridged.getNumParameters() }
 
   /// The total number of arguments.
   ///
@@ -78,23 +70,23 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   public var numArguments: Int { numIndirectResultArguments + numParameterArguments }
 
   public var hasSelfArgument: Bool {
-    SILFunction_getSelfArgumentIndex(bridged) >= 0
+    bridged.getSelfArgumentIndex() >= 0
   }
 
   public var selfArgumentIndex: Int {
-    let selfIdx = SILFunction_getSelfArgumentIndex(bridged)
+    let selfIdx = bridged.getSelfArgumentIndex()
     assert(selfIdx >= 0)
     return selfIdx
   }
 
   public var argumentTypes: ArgumentTypeArray { ArgumentTypeArray(function: self) }
-  public var resultType: Type { SILFunction_getSILResultType(bridged).type }
+  public var resultType: Type { bridged.getSILResultType().type }
 
   public func getArgumentConvention(for argumentIndex: Int) -> ArgumentConvention {
     if argumentIndex < numIndirectResultArguments {
       return .indirectOut
     }
-    return SILFunction_getSILArgumentConvention(bridged, argumentIndex).convention
+    return bridged.getSILArgumentConvention(argumentIndex).convention
   }
 
   public var returnInstruction: ReturnInst? {
@@ -109,20 +101,20 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   ///
   /// For example, `public` linkage.
   public var isPossiblyUsedExternally: Bool {
-    return SILFunction_isPossiblyUsedExternally(bridged) != 0
+    return bridged.isPossiblyUsedExternally()
   }
 
   /// True, if the linkage of the function indicates that it has a definition outside the
   /// current compilation unit.
   ///
   /// For example, `public_external` linkage.
   public var isAvailableExternally: Bool {
-    return SILFunction_isAvailableExternally(bridged) != 0
+    return bridged.isAvailableExternally()
   }
 
   public func hasSemanticsAttribute(_ attr: StaticString) -> Bool {
     attr.withUTF8Buffer { (buffer: UnsafeBufferPointer<UInt8>) in
-      SILFunction_hasSemanticsAttr(bridged, llvm.StringRef(buffer.baseAddress!, buffer.count)) != 0
+      bridged.hasSemanticsAttr(llvm.StringRef(buffer.baseAddress!, buffer.count))
     }
   }
 
@@ -175,24 +167,23 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
 
   /// The effect attribute which is specified in the source code (if any).
   public var effectAttribute: EffectAttribute {
-    switch SILFunction_getEffectAttribute(bridged) {
-      case EffectKind_none: return .none
-      case EffectKind_readNone: return .readNone
-      case EffectKind_readOnly: return .readOnly
-      case EffectKind_releaseNone: return .releaseNone
-      default: fatalError()
+    switch bridged.getEffectAttribute() {
+      case .ReadNone: return .readNone
+      case .ReadOnly: return .readOnly
+      case .ReleaseNone: return .releaseNone
+      default: return .none
     }
   }
 
   /// True, if the function runs with a swift 5.1 runtime.
   /// Note that this is function specific, because inlinable functions are de-serialized
   /// in a client module, which might be compiled with a different deployment target.
   public var isSwift51RuntimeAvailable: Bool {
-    SILFunction_isSwift51RuntimeAvailable(bridged) != 0
+    bridged.isSwift51RuntimeAvailable()
   }
 
   public var needsStackProtection: Bool {
-    SILFunction_needsStackProtection(bridged) != 0
+    bridged.needsStackProtection()
   }
 
   public var isDeinitBarrier: Bool {
@@ -212,7 +203,7 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     }
 
     let metatype = unsafeBitCast(Function.self, to: SwiftMetatype.self)
-    Function_register(metatype,
+    BridgedFunction.registerBridging(metatype,
       // initFn
       { (f: BridgedFunction, data: UnsafeMutableRawPointer, size: Int) in
         checkLayout(&f.function.effects, data: data, size: size)
@@ -245,36 +236,36 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
         s._withStringRef { OStream_write(os, $0) }
       },
       // parseFn:
-      { (f: BridgedFunction, str: llvm.StringRef, mode: ParseEffectsMode, argumentIndex: Int, paramNames: BridgedArrayRef) -> BridgedParsingError in
+      { (f: BridgedFunction, str: llvm.StringRef, mode: BridgedFunction.ParseEffectsMode, argumentIndex: Int, paramNames: BridgedArrayRef) -> BridgedFunction.ParsingError in
         do {
           var parser = StringParser(str.string)
           let function = f.function
 
           switch mode {
-          case ParseArgumentEffectsFromSource:
+          case .argumentEffectsFromSource:
             let paramToIdx = paramNames.withElements(ofType: llvm.StringRef.self) {
                 (buffer: UnsafeBufferPointer<llvm.StringRef>) -> Dictionary<String, Int> in
               let keyValPairs = buffer.enumerated().lazy.map { ($0.1.string, $0.0) }
               return Dictionary(uniqueKeysWithValues: keyValPairs)
             }
             let effect = try parser.parseEffectFromSource(for: function, params: paramToIdx)
             function.effects.escapeEffects.arguments.append(effect)
-          case ParseArgumentEffectsFromSIL:
+          case .argumentEffectsFromSIL:
             try parser.parseEffectsFromSIL(argumentIndex: argumentIndex, to: &function.effects)
-          case ParseGlobalEffectsFromSIL:
+          case .globalEffectsFromSIL:
             try parser.parseGlobalSideEffectsFromSIL(to: &function.effects)
-          case ParseMultipleEffectsFromSIL:
+          case .multipleEffectsFromSIL:
             try parser.parseEffectsFromSIL(to: &function.effects)
           default:
             fatalError("invalid ParseEffectsMode")
           }
           if !parser.isEmpty() { try parser.throwError("syntax error") }
         } catch let error as ParsingError {
-          return BridgedParsingError(message: error.message.utf8Start, position: error.position)
+          return BridgedFunction.ParsingError(message: error.message.utf8Start, position: error.position)
         } catch {
           fatalError()
         }
-        return BridgedParsingError(message: nil, position: 0)
+        return BridgedFunction.ParsingError(message: nil, position: 0)
       },
       // copyEffectsFn
       { (toFunc: BridgedFunction, fromFunc: BridgedFunction) -> Int in
@@ -295,25 +286,25 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
         return 1
       },
       // getEffectInfo
-      {  (f: BridgedFunction, idx: Int) -> BridgedEffectInfo in
+      {  (f: BridgedFunction, idx: Int) -> BridgedFunction.EffectInfo in
         let effects = f.function.effects
         if idx < effects.escapeEffects.arguments.count {
           let effect = effects.escapeEffects.arguments[idx]
-          return BridgedEffectInfo(argumentIndex: effect.argumentIndex,
-                                   isDerived: effect.isDerived, isEmpty: false, isValid: true)
+          return BridgedFunction.EffectInfo(argumentIndex: effect.argumentIndex,
+                                            isDerived: effect.isDerived, isEmpty: false, isValid: true)
         }
         if let sideEffects = effects.sideEffects {
           let globalIdx = idx - effects.escapeEffects.arguments.count
           if globalIdx == 0 {
-            return BridgedEffectInfo(argumentIndex: -1, isDerived: true, isEmpty: false, isValid: true)
+            return BridgedFunction.EffectInfo(argumentIndex: -1, isDerived: true, isEmpty: false, isValid: true)
           }
           let seIdx = globalIdx - 1
           if seIdx < sideEffects.arguments.count {
-            return BridgedEffectInfo(argumentIndex: seIdx, isDerived: true,
-                                     isEmpty: sideEffects.arguments[seIdx].isEmpty, isValid: true)
+            return BridgedFunction.EffectInfo(argumentIndex: seIdx, isDerived: true,
+                                              isEmpty: sideEffects.arguments[seIdx].isEmpty, isValid: true)
           }
         }
-        return BridgedEffectInfo(argumentIndex: -1, isDerived: false, isEmpty: true, isValid: false)
+        return BridgedFunction.EffectInfo(argumentIndex: -1, isDerived: false, isEmpty: true, isValid: false)
       },
       // getMemBehaviorFn
       { (f: BridgedFunction, observeRetains: Bool) -> BridgedMemoryBehavior in
@@ -333,10 +324,10 @@ public struct ArgumentTypeArray : RandomAccessCollection, FormattedLikeArray {
   fileprivate let function: Function
 
   public var startIndex: Int { return 0 }
-  public var endIndex: Int { SILFunction_getNumSILArguments(function.bridged) }
+  public var endIndex: Int { function.bridged.getNumSILArguments() }
 
   public subscript(_ index: Int) -> Type {
-    SILFunction_getSILArgumentType(function.bridged, index).type
+    function.bridged.getSILArgumentType(index).type
   }
 }
 
@@ -381,7 +372,7 @@ public struct BasicBlockList : CollectionLikeSequence, IteratorProtocol {
 
   public func reversed() -> ReverseBasicBlockList {
     if let block = currentBlock {
-      let lastBlock = SILFunction_lastBlock(block.parentFunction.bridged).block
+      let lastBlock = block.parentFunction.bridged.getLastBlock().block
       return ReverseBasicBlockList(first: lastBlock)
     }
     return ReverseBasicBlockList(first: nil)