Swift Bridging: use C++ instead of C bridging for BridgedVTable and BridgedVTableEntry

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift

@@ -37,12 +37,12 @@ struct ModulePassContext : Context {
 
   struct VTableArray : BridgedRandomAccessCollection {
     fileprivate let bridged: BridgedVTableArray
-    
+
     var startIndex: Int { return 0 }
-    var endIndex: Int { return Int(bridged.count) }
-    
+    var endIndex: Int { return bridged.count }
+
     subscript(_ index: Int) -> VTable {
-      assert(index >= 0 && index < bridged.count)
+      assert(index >= startIndex && index < endIndex)
       return VTable(bridged: bridged.vTables![index])
     }
   }

SwiftCompilerSources/Sources/SIL/VTable.swift

@@ -20,32 +20,34 @@ public struct VTable : CustomStringConvertible, NoReflectionChildren {
   public struct Entry : CustomStringConvertible, NoReflectionChildren {
     fileprivate let bridged: BridgedVTableEntry
 
-    public var function: Function { SILVTableEntry_getFunction(bridged).function }
+    public var function: Function { bridged.getImplementation().function }
 
     public var description: String {
-      let stdString = SILVTableEntry_debugDescription(bridged)
+      let stdString = bridged.getDebugDescription()
       return String(_cxxString: stdString)
     }
   }
 
   public struct EntryArray : BridgedRandomAccessCollection {
-    fileprivate let bridgedArray: BridgedArrayRef
+    fileprivate let base: BridgedVTableEntry
+    public let count: Int
 
     public var startIndex: Int { return 0 }
-    public var endIndex: Int { return Int(bridgedArray.numElements) }
+    public var endIndex: Int { return count }
 
     public subscript(_ index: Int) -> Entry {
-      assert(index >= 0 && index < endIndex)
-      return Entry(bridged: BridgedVTableEntry(ptr: bridgedArray.data! + index &* BridgedVTableEntrySize))
+      assert(index >= startIndex && index < endIndex)
+      return Entry(bridged: BridgedVTableEntry(entry: base.entry + index))
     }
   }
 
   public var entries: EntryArray {
-    EntryArray(bridgedArray: SILVTable_getEntries(bridged))
+    let entries = bridged.getEntries()
+    return EntryArray(base: entries.base, count: entries.count)
   }
 
   public var description: String {
-    let stdString = SILVTable_debugDescription(bridged)
+    let stdString = bridged.getDebugDescription()
     return String(_cxxString: stdString)
   }
 }

include/swift/SIL/SILBridging.h

@@ -20,6 +20,7 @@
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILLocation.h"
 #include "swift/SIL/SILWitnessTable.h"
+#include "swift/SIL/SILVTable.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include <string>
@@ -31,7 +32,6 @@ struct OptionalBridgedOperand;
 struct OptionalBridgedSuccessor;
 
 enum {
-  BridgedVTableEntrySize = 5 * sizeof(uintptr_t),
   BridgedWitnessTableEntrySize = 5 * sizeof(uintptr_t)
 };
 
@@ -133,14 +133,6 @@ struct BridgedOperandArray {
   SwiftInt count;
 };
 
-typedef struct {
-  const void * _Nonnull ptr;
-} BridgedVTable;
-
-typedef struct {
-  const void * _Nonnull ptr;
-} BridgedVTableEntry;
-
 typedef struct {
   const void * _Nonnull ptr;
 } BridgedWitnessTable;
@@ -237,6 +229,34 @@ typedef struct {
   SwiftObject obj;
 } BridgedMultiValueResult;
 
+struct BridgedVTableEntry {
+  const swift::SILVTableEntry * _Nonnull entry;
+
+  std::string getDebugDescription() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedFunction getImplementation() const {
+    return {entry->getImplementation()};
+  }
+};
+
+struct BridgedVTableEntryArray {
+  BridgedVTableEntry base;
+  SwiftInt count;
+};
+
+struct BridgedVTable {
+  const swift::SILVTable * _Nonnull vTable;
+
+  std::string getDebugDescription() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedVTableEntryArray getEntries() const {
+    auto entries = vTable->getEntries();
+    return {{entries.data()}, (SwiftInt)entries.size()};
+  }
+};
+
 typedef struct {
   const unsigned char * _Nullable message;
   SwiftInt position;
@@ -353,11 +373,6 @@ llvm::StringRef SILGlobalVariable_getName(BridgedGlobalVar global);
 std::string SILGlobalVariable_debugDescription(BridgedGlobalVar global);
 SwiftInt SILGlobalVariable_isLet(BridgedGlobalVar global);
 
-std::string SILVTable_debugDescription(BridgedVTable vTable);
-BridgedArrayRef SILVTable_getEntries(BridgedVTable vTable);
-std::string SILVTableEntry_debugDescription(BridgedVTableEntry entry);
-BridgedFunction SILVTableEntry_getFunction(BridgedVTableEntry entry);
-
 std::string SILWitnessTable_debugDescription(BridgedWitnessTable table);
 BridgedArrayRef SILWitnessTable_getEntries(BridgedWitnessTable table);
 std::string SILDefaultWitnessTable_debugDescription(BridgedDefaultWitnessTable table);

include/swift/SIL/SILBridgingUtils.h

@@ -67,14 +67,6 @@ inline SILGlobalVariable *castToGlobal(BridgedGlobalVar global) {
   return static_cast<SILGlobalVariable *>(global.obj);
 }
 
-inline const SILVTable *castToVTable(BridgedVTable vTable) {
-  return static_cast<const SILVTable *>(vTable.ptr);
-}
-
-inline const SILVTableEntry *castToVTableEntry(BridgedVTableEntry entry) {
-  return static_cast<const SILVTableEntry *>(entry.ptr);
-}
-
 inline const SILWitnessTable *castToWitnessTable(BridgedWitnessTable table) {
   return static_cast<const SILWitnessTable *>(table.ptr);
 }

include/swift/SILOptimizer/OptimizerBridging.h

@@ -29,7 +29,7 @@ typedef struct {
 
 typedef struct {
   const BridgedVTable * _Nullable vTables;
-  size_t count;
+  SwiftInt count;
 } BridgedVTableArray;
 
 typedef struct {

lib/SIL/Utils/SILBridging.cpp

@@ -713,34 +713,22 @@ SwiftInt SILGlobalVariable_isLet(BridgedGlobalVar global) {
 //                            SILVTable
 //===----------------------------------------------------------------------===//
 
-static_assert(BridgedVTableEntrySize == sizeof(SILVTableEntry),
-              "wrong bridged VTableEntry size");
-
-std::string SILVTable_debugDescription(BridgedVTable vTable) {
+std::string BridgedVTable::getDebugDescription() const {
   std::string str;
   llvm::raw_string_ostream os(str);
-  castToVTable(vTable)->print(os);
+  vTable->print(os);
   str.pop_back(); // Remove trailing newline.
   return str;
 }
 
-BridgedArrayRef SILVTable_getEntries(BridgedVTable vTable) {
-  auto entries = castToVTable(vTable)->getEntries();
-  return {(const unsigned char *)entries.data(), entries.size()};
-}
-
-std::string SILVTableEntry_debugDescription(BridgedVTableEntry entry) {
+std::string BridgedVTableEntry::getDebugDescription() const {
   std::string str;
   llvm::raw_string_ostream os(str);
-  castToVTableEntry(entry)->print(os);
+  entry->print(os);
   str.pop_back(); // Remove trailing newline.
   return str;
 }
 
-BridgedFunction SILVTableEntry_getFunction(BridgedVTableEntry entry) {
-  return {castToVTableEntry(entry)->getImplementation()};
-}
-
 //===----------------------------------------------------------------------===//
 //                    SILVWitnessTable, SILDefaultWitnessTable
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1668,7 +1668,7 @@ PassContext_nextFunctionInModule(BridgedFunction function) {
 BridgedVTableArray PassContext_getVTables(BridgedPassContext context) {
   SILModule *mod = castToPassInvocation(context)->getPassManager()->getModule();
   auto vTables = mod->getVTables();
-  return {(const BridgedVTable *)vTables.data(), vTables.size()};
+  return {(const BridgedVTable *)vTables.data(), (SwiftInt)vTables.size()};
 }
 
 OptionalBridgedWitnessTable