Swift SIL: add bridging for vTables

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift

@@ -15,8 +15,8 @@ import OptimizerBridging
 
 /// The context which is passed to a `ModulePass`'s run-function.
 ///
-/// It provides access to all functions of a module, but it doesn't provide any
-/// APIs to modify functions.
+/// It provides access to all functions, v-tables and witness tables of a module,
+/// but it doesn't provide any APIs to modify functions.
 /// In order to modify a function, a module pass must use `transform(function:)`.
 struct ModulePassContext {
   let _bridged: BridgedPassContext
@@ -34,11 +34,27 @@ struct ModulePassContext {
       return nil
     }
   }
-  
+
+  struct VTableArray : BridgedRandomAccessCollection {
+    fileprivate let bridged: BridgedVTableArray
+    
+    var startIndex: Int { return 0 }
+    var endIndex: Int { return Int(bridged.count) }
+    
+    subscript(_ index: Int) -> VTable {
+      precondition(index >= 0 && index < bridged.count)
+      return VTable(bridged: bridged.vTables![index])
+    }
+  }
+
   var functions: FunctionList {
     FunctionList(first: PassContext_firstFunctionInModule(_bridged).function)
   }
 
+  var vTables: VTableArray {
+    VTableArray(bridged: PassContext_getVTables(_bridged))
+  }
+  
   /// Run a closure with a `PassContext` for a function, which allows to modify that function.
   ///
   /// Only a single `transform` can be alive at the same time, i.e. it's not allowed to nest

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -25,5 +25,6 @@ add_swift_compiler_module(SIL
     SubstitutionMap.swift
     Type.swift
     Utils.swift
-    Value.swift)
+    Value.swift
+    VTable.swift)
 

SwiftCompilerSources/Sources/SIL/VTable.swift

@@ -0,0 +1,55 @@
+//===--- VTable.swift -----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SILBridging
+
+public struct VTable : CustomStringConvertible, CustomReflectable {
+  let bridged: BridgedVTable
+
+  public init(bridged: BridgedVTable) { self.bridged = bridged }
+
+  public struct Entry : CustomStringConvertible, CustomReflectable {
+    fileprivate let bridged: BridgedVTableEntry
+    
+    public var function: Function { SILVTableEntry_getFunction(bridged).function }
+
+    public var description: String {
+      let stdString = SILVTableEntry_debugDescription(bridged)
+      return String(_cxxString: stdString)
+    }
+
+    public var customMirror: Mirror { Mirror(self, children: []) }
+  }
+
+  public struct EntryArray : BridgedRandomAccessCollection {
+    fileprivate let bridgedArray: BridgedArrayRef
+    
+    public var startIndex: Int { return 0 }
+    public var endIndex: Int { return Int(bridgedArray.numElements) }
+    
+    public subscript(_ index: Int) -> Entry {
+      precondition(index >= 0 && index < endIndex)
+      return Entry(bridged: BridgedVTableEntry(ptr: bridgedArray.data! + index &* BridgedVTableEntrySize))
+    }
+  }
+
+  public var entries: EntryArray {
+    EntryArray(bridgedArray: SILVTable_getEntries(bridged))
+  }
+
+  public var description: String {
+    let stdString = SILVTable_debugDescription(bridged)
+    return String(_cxxString: stdString)
+  }
+
+  public var customMirror: Mirror { Mirror(self, children: []) }
+}

include/swift/SIL/SILBridging.h

@@ -23,7 +23,8 @@ SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 enum {
   BridgedOperandSize = 4 * sizeof(uintptr_t),
-  BridgedSuccessorSize = 4 * sizeof(uintptr_t) + sizeof(uint64_t)
+  BridgedSuccessorSize = 4 * sizeof(uintptr_t) + sizeof(uint64_t),
+  BridgedVTableEntrySize = 5 * sizeof(uintptr_t)
 };
 
 enum ChangeNotificationKind {
@@ -68,6 +69,14 @@ typedef struct {
   const void * _Nullable succ;
 } OptionalBridgedSuccessor;
 
+typedef struct {
+  const void * _Nonnull ptr;
+} BridgedVTable;
+
+typedef struct {
+  const void * _Nonnull ptr;
+} BridgedVTableEntry;
+
 typedef struct {
   SwiftObject obj;
 } BridgedFunction;
@@ -233,6 +242,11 @@ 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);
+
 OptionalBridgedBasicBlock SILBasicBlock_next(BridgedBasicBlock block);
 OptionalBridgedBasicBlock SILBasicBlock_previous(BridgedBasicBlock block);
 BridgedFunction SILBasicBlock_getFunction(BridgedBasicBlock block);

include/swift/SIL/SILBridgingUtils.h

@@ -16,6 +16,7 @@
 #include "swift/SIL/SILBridging.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILGlobalVariable.h"
+#include "swift/SIL/SILVTable.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <string>
@@ -84,6 +85,14 @@ 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 ValueOwnershipKind castToOwnership(BridgedOwnership ownership) {
   switch (ownership) {
     case Ownership_Unowned:    return OwnershipKind::Unowned;

include/swift/SILOptimizer/OptimizerBridging.h

@@ -27,6 +27,11 @@ typedef struct {
   BridgedPassContext passContext;
 } BridgedInstructionPassCtxt;
 
+typedef struct {
+  const BridgedVTable * _Nullable vTables;
+  size_t count;
+} BridgedVTableArray;
+
 typedef struct {
   const void * _Nonnull aliasAnalysis;
 } BridgedAliasAnalysis;
@@ -166,6 +171,7 @@ OptionalBridgedFunction
 PassContext_firstFunctionInModule(BridgedPassContext context);
 OptionalBridgedFunction
 PassContext_nextFunctionInModule(BridgedFunction function);
+BridgedVTableArray PassContext_getVTables(BridgedPassContext context);
 
 OptionalBridgedFunction
 PassContext_loadFunction(BridgedPassContext context, llvm::StringRef name);

lib/SIL/Utils/SILBridging.cpp

@@ -549,6 +549,38 @@ SwiftInt SILGlobalVariable_isLet(BridgedGlobalVar global) {
   return castToGlobal(global)->isLet();
 }
 
+//===----------------------------------------------------------------------===//
+//                            SILVTable
+//===----------------------------------------------------------------------===//
+
+static_assert(BridgedVTableEntrySize == sizeof(SILVTableEntry),
+              "wrong bridged VTableEntry size");
+
+std::string SILVTable_debugDescription(BridgedVTable vTable) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+  castToVTable(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 str;
+  llvm::raw_string_ostream os(str);
+  castToVTableEntry(entry)->print(os);
+  str.pop_back(); // Remove trailing newline.
+  return str;
+}
+
+BridgedFunction SILVTableEntry_getFunction(BridgedVTableEntry entry) {
+  return {castToVTableEntry(entry)->getImplementation()};
+}
+
 //===----------------------------------------------------------------------===//
 //                               SILInstruction
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1573,6 +1573,12 @@ PassContext_nextFunctionInModule(BridgedFunction function) {
   return {&*nextIter};
 }
 
+BridgedVTableArray PassContext_getVTables(BridgedPassContext context) {
+  SILModule *mod = castToPassInvocation(context)->getPassManager()->getModule();
+  auto vTables = mod->getVTables();
+  return {(const BridgedVTable *)vTables.data(), vTables.size()};
+}
+
 OptionalBridgedFunction
 PassContext_loadFunction(BridgedPassContext context, StringRef name) {
   SILModule *mod = castToPassInvocation(context)->getPassManager()->getModule();