[interop][SwiftToCxx] dispatch virtual Swift methods using a relative offset into the vtable for classes deriving from resilient classes

hyp · hyp · commit 540202fed8fd · 2023-02-13T10:30:32.000-08:00
diff --git a/include/swift/IRGen/IRABIDetailsProvider.h b/include/swift/IRGen/IRABIDetailsProvider.h
@@ -255,6 +255,9 @@ class IRABIDetailsProvider {
       Direct,
       /// An indirect call that can be made via a static offset in a vtable.
       IndirectVTableStaticOffset,
+      /// An indirect call that should be made via an offset relative to
+      /// external base value in a vtable.
+      IndirectVTableRelativeOffset,
       /// The call should be made via the provided thunk function.
       Thunk
     };
@@ -273,39 +276,68 @@ class IRABIDetailsProvider {
                                 discriminator);
     }
 
+    static MethodDispatchInfo indirectVTableRelativeOffset(
+        size_t bitOffset, std::string symbolName,
+        Optional<PointerAuthDiscriminator> discriminator) {
+      return MethodDispatchInfo(Kind::IndirectVTableRelativeOffset, bitOffset,
+                                symbolName, discriminator);
+    }
+
     static MethodDispatchInfo thunk(std::string thunkName) {
       return MethodDispatchInfo(Kind::Thunk, 0, thunkName);
     }
 
     Kind getKind() const { return kind; }
+
+    /// Return the bit offset into the vtable from which the method pointer
+    /// should be loaded.
     size_t getStaticBitOffset() const {
       assert(kind == Kind::IndirectVTableStaticOffset);
       return bitOffset;
     }
     Optional<PointerAuthDiscriminator> getPointerAuthDiscriminator() const {
-      assert(kind == Kind::IndirectVTableStaticOffset);
+      assert(kind == Kind::IndirectVTableStaticOffset ||
+             kind == Kind::IndirectVTableRelativeOffset);
       return discriminator;
     }
     StringRef getThunkSymbolName() const {
       assert(kind == Kind::Thunk);
-      return thunkName;
+      return symbolName;
+    }
+
+    /// Return the bit offset relative to base offset value into the vtable from
+    /// which the method pointer should be loaded.
+    size_t getRelativeBitOffset() const {
+      assert(kind == Kind::IndirectVTableRelativeOffset);
+      return bitOffset;
+    }
+
+    /// Return the external symbol from which the relative base offset should be
+    /// loaded.
+    StringRef getBaseOffsetSymbolName() const {
+      assert(kind == Kind::IndirectVTableRelativeOffset);
+      return symbolName;
     }
 
   private:
-    MethodDispatchInfo(Kind kind, size_t bitOffset, std::string thunkName = "",
+    MethodDispatchInfo(Kind kind, size_t bitOffset, std::string symbolName = "",
                        Optional<PointerAuthDiscriminator> discriminator = None)
-        : kind(kind), bitOffset(bitOffset), thunkName(thunkName),
+        : kind(kind), bitOffset(bitOffset), symbolName(symbolName),
           discriminator(discriminator) {}
 
     Kind kind;
     size_t bitOffset;
-    std::string thunkName;
+    std::string symbolName;
     Optional<PointerAuthDiscriminator> discriminator;
   };
 
   Optional<MethodDispatchInfo>
   getMethodDispatchInfo(const AbstractFunctionDecl *funcDecl);
 
+  /// Returns the type of the base offset value located at the specific class
+  /// base offset symbol.
+  Type getClassBaseOffsetSymbolType() const;
+
 private:
   std::unique_ptr<IRABIDetailsProviderImpl> impl;
 };
diff --git a/lib/IRGen/IRABIDetailsProvider.cpp b/lib/IRGen/IRABIDetailsProvider.cpp
@@ -256,11 +256,20 @@ class IRABIDetailsProviderImpl {
             /*bitOffset=*/mi->TheOffset.getStaticOffset().getValue(),
             getMethodPointerAuthInfo(funcDecl, silDecl));
       }
-      return {};
+      assert(mi->TheOffset.isDynamic());
+      return MethodDispatchInfo::indirectVTableRelativeOffset(
+          mi->TheOffset.getRelativeOffset().getValue(),
+          LinkEntity::forClassMetadataBaseOffset(parentClass).mangleAsString(),
+          getMethodPointerAuthInfo(funcDecl, silDecl));
     }
     llvm_unreachable("invalid kind");
   }
 
+  Type getClassBaseOffsetSymbolType() const {
+    return *getPrimitiveTypeFromLLVMType(
+        silMod->getASTContext(), IGM.ClassMetadataBaseOffsetTy->elements()[0]);
+  }
+
   Lowering::TypeConverter typeConverter;
   // Default silOptions are sufficient, as we don't need to generated SIL.
   SILOptions silOpts;
@@ -470,3 +479,7 @@ IRABIDetailsProvider::getMethodDispatchInfo(
     const AbstractFunctionDecl *funcDecl) {
   return impl->getMethodDispatchInfo(funcDecl);
 }
+
+Type IRABIDetailsProvider::getClassBaseOffsetSymbolType() const {
+  return impl->getClassBaseOffsetSymbolType();
+}
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -1443,6 +1443,21 @@ class DeclAndTypePrinter::Implementation
               FD, funcABI, resultTy, funcTy, dispatchInfo->getThunkSymbolName(),
               "dispatch thunk for");
           assert(!thunkRepresentation.isUnsupported());
+        } else if (dispatchInfo->getKind() ==
+                   IRABIDetailsProvider::MethodDispatchInfo::Kind::
+                       IndirectVTableRelativeOffset) {
+          // Emit the C signature for the class metadata base offset.
+          owningPrinter.interopContext.runIfStubForDeclNotEmitted(
+              dispatchInfo->getBaseOffsetSymbolName(), [&] {
+                auto baseClassOffsetType =
+                    owningPrinter.interopContext.getIrABIDetails()
+                        .getClassBaseOffsetSymbolType();
+                os << "SWIFT_EXTERN ";
+                ClangSyntaxPrinter(os).printKnownCType(
+                    baseClassOffsetType, owningPrinter.typeMapping);
+                os << ' ' << dispatchInfo->getBaseOffsetSymbolName()
+                   << "; // class metadata base offset\n";
+              });
         }
       }
     }
diff --git a/lib/PrintAsClang/PrintClangClassType.cpp b/lib/PrintAsClang/PrintClangClassType.cpp
@@ -50,8 +50,6 @@ void ClangClassTypePrinter::printClassTypeDecl(
     ClangSyntaxPrinter(baseQualNameOS)
         .printModuleNamespaceQualifiersIfNeeded(parentClass->getModuleContext(),
                                                 typeDecl->getModuleContext());
-    if (!baseQualNameOS.str().empty())
-      baseQualNameOS << "::";
     baseQualNameOS << baseNameOS.str();
   } else {
     baseClassName = "RefCountedClass";
diff --git a/lib/PrintAsClang/PrintClangFunction.cpp b/lib/PrintAsClang/PrintClangFunction.cpp
@@ -1105,6 +1105,7 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
     case DispatchKindTy::Direct:
       break;
     case DispatchKindTy::IndirectVTableStaticOffset:
+    case DispatchKindTy::IndirectVTableRelativeOffset:
       os << "void ***selfPtr_ = reinterpret_cast<void ***>( "
             "::swift::_impl::_impl_RefCountedClass::getOpaquePointer(*this));"
             "\n";
@@ -1126,8 +1127,15 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
       os << " func;\n";
       os << "};\n";
       os << "FTypeAddress *fptrptr_ = reinterpret_cast<FTypeAddress *>(vtable_ "
-            "+ "
-         << (dispatchInfo->getStaticBitOffset() / 8) << ");\n";
+            "+ ";
+      if (dispatchInfo->getKind() == DispatchKindTy::IndirectVTableStaticOffset)
+        os << (dispatchInfo->getStaticBitOffset() / 8);
+      else
+        os << '(' << cxx_synthesis::getCxxImplNamespaceName()
+           << "::" << dispatchInfo->getBaseOffsetSymbolName()
+           << " / sizeof(void *)) + "
+           << (dispatchInfo->getRelativeBitOffset() / 8);
+      os << ");\n";
       indirectFunctionVar = StringRef("fptrptr_->func");
       break;
     case DispatchKindTy::Thunk:
diff --git a/test/Interop/SwiftToCxx/class/swift-subclass-of-resilient-class-virtual-method-dispatch-execution.cpp b/test/Interop/SwiftToCxx/class/swift-subclass-of-resilient-class-virtual-method-dispatch-execution.cpp
@@ -0,0 +1,62 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/swift-subclass-of-resilient-class-virtual-method-dispatch.swift -D RESILIENT_MODULE -module-name Class -emit-module -emit-module-path %t/Class.swiftmodule -enable-library-evolution -clang-header-expose-decls=all-public -emit-clang-header-path %t/class.h
+
+// RUN: %target-swift-frontend %S/swift-subclass-of-resilient-class-virtual-method-dispatch.swift -I %t -typecheck -module-name UseClass -clang-header-expose-decls=all-public -emit-clang-header-path %t/useclass.h
+
+// RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-class-execution.o
+
+// RUN: %target-interop-build-swift -c %S/swift-subclass-of-resilient-class-virtual-method-dispatch.swift -D RESILIENT_MODULE -o %t/class.o -module-name Class -enable-library-evolution -Xfrontend -entry-point-function-name -Xfrontend swiftMain2
+
+// RUN: %target-interop-build-swift %S/swift-subclass-of-resilient-class-virtual-method-dispatch.swift -I %t -o %t/swift-class-execution -Xlinker %t/swift-class-execution.o -Xlinker %t/class.o  -module-name UseClass -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+
+// RUN: %target-codesign %t/swift-class-execution
+// RUN: %target-run %t/swift-class-execution | %FileCheck %s
+
+#include "class.h"
+#include "useclass.h"
+#include <assert.h>
+
+using namespace UseClass;
+
+int main() {
+  auto derived = createCrossModuleDerivedClass();
+  Class::BaseClass derivedAsBase = derived;
+  auto derivedDerived = createCrossModuleDerivedDerivedClass();
+  CrossModuleDerivedClass derivedDerivedAsDerived = derivedDerived;
+
+  {
+    derived.virtualMethod();
+    assert(derived.getComputedProp() == -56);
+// CHECK: CrossModuleDerivedClass.virtualMethod
+  }
+
+  {
+    derived.virtualMethodInDerived();
+// CHECK-NEXT: CrossModuleDerivedClass.virtualMethodInDerived
+    derivedDerived.virtualMethodInDerived();
+// CHECK-NEXT: CrossModuleDerivedDerivedClass.virtualMethodInDerived
+    derivedDerivedAsDerived.virtualMethodInDerived();
+// CHECK-NEXT: CrossModuleDerivedDerivedClass.virtualMethodInDerived
+  }
+
+  {
+    derived.virtualMethod2InDerived();
+// CHECK-NEXT: CrossModuleDerivedClass.virtualMethod2InDerived
+    derivedDerived.virtualMethod2InDerived();
+// CHECK-NEXT: CrossModuleDerivedDerivedClass.virtualMethod2InDerived
+    derivedDerivedAsDerived.virtualMethod2InDerived();
+// CHECK-NEXT: CrossModuleDerivedDerivedClass.virtualMethod2InDerived
+  }
+
+  {
+    swift::Int x;
+    x = derived.getDerivedComputedProp();
+    assert(x == 23);
+    x = derivedDerived.getDerivedComputedProp();
+    assert(x == -95);
+    x = derivedDerivedAsDerived.getDerivedComputedProp();
+    assert(x == -95);
+  }
+  return 0;
+}
diff --git a/test/Interop/SwiftToCxx/class/swift-subclass-of-resilient-class-virtual-method-dispatch.swift b/test/Interop/SwiftToCxx/class/swift-subclass-of-resilient-class-virtual-method-dispatch.swift
@@ -0,0 +1,113 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -D RESILIENT_MODULE -module-name Class -emit-module -emit-module-path %t/Class.swiftmodule -enable-library-evolution -clang-header-expose-decls=all-public -emit-clang-header-path %t/class.h
+
+// RUN: %target-swift-frontend %s -I %t -typecheck -module-name UseClass -clang-header-expose-decls=all-public -emit-clang-header-path %t/useclass.h
+
+// RUN: %FileCheck %s < %t/useclass.h
+
+// FIXME: add import automatically?
+// RUN: echo '#include "class.h"' > %t/fixed-useclass.h
+// RUN: cat %t/useclass.h     >> %t/fixed-useclass.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/fixed-useclass.h)
+
+#if RESILIENT_MODULE
+
+open class BaseClass {
+  var field: Int64
+
+  public init() {
+    field = 0
+  }
+  open func virtualMethod() {
+    print("BaseClass.virtualMethod")
+  }
+  open var computedProp: Int {
+    return 11
+  }
+}
+
+#else
+
+import Class
+
+public class CrossModuleDerivedClass: BaseClass {
+  override public init() {}
+  override public func virtualMethod() {
+    print("CrossModuleDerivedClass.virtualMethod")
+  }
+  override public var computedProp: Int {
+    return -56
+  }
+
+  public func virtualMethodInDerived() {
+    print("CrossModuleDerivedClass.virtualMethodInDerived")
+  }
+  public var derivedComputedProp: Int {
+    return 23
+  }
+  public func virtualMethod2InDerived() {
+    print("CrossModuleDerivedClass.virtualMethod2InDerived")
+  }
+}
+
+public class CrossModuleDerivedDerivedClass: CrossModuleDerivedClass {
+  override public init() {}
+  override public func virtualMethodInDerived() {
+    print("CrossModuleDerivedDerivedClass.virtualMethodInDerived")
+  }
+  override public var derivedComputedProp: Int {
+    return -95
+  }
+  override public final func virtualMethod2InDerived() {
+    print("CrossModuleDerivedDerivedClass.virtualMethod2InDerived")
+  }
+}
+
+public func createCrossModuleDerivedClass() -> CrossModuleDerivedClass {
+    return CrossModuleDerivedClass()
+}
+
+public func createCrossModuleDerivedDerivedClass() -> CrossModuleDerivedDerivedClass {
+    return CrossModuleDerivedDerivedClass()
+}
+
+#endif
+
+// CHECK: SWIFT_EXTERN void $s8UseClass018CrossModuleDerivedB0C015virtualMethodInE0yyF(SWIFT_CONTEXT void * _Nonnull _self) SWIFT_NOEXCEPT SWIFT_CALL; // virtualMethodInDerived()
+// CHECK-NEXT: SWIFT_EXTERN uint64_t $s8UseClass018CrossModuleDerivedB0CMo; // class metadata base offset
+// CHECK-NEXT: SWIFT_EXTERN ptrdiff_t $s8UseClass018CrossModuleDerivedB0C19derivedComputedPropSivg(SWIFT_CONTEXT void * _Nonnull _self) SWIFT_NOEXCEPT SWIFT_CALL;
+// CHECK-NEXT: SWIFT_EXTERN void $s8UseClass018CrossModuleDerivedB0C016virtualMethod2InE0yyF(SWIFT_CONTEXT void * _Nonnull _self) SWIFT_NOEXCEPT SWIFT_CALL; // virtualMethod2InDerived()
+
+
+// CHECK:      void CrossModuleDerivedClass::virtualMethod() {
+// CHECK-NEXT: return _impl::$s5Class04BaseA0C13virtualMethodyyFTj(::swift::_impl::_impl_RefCountedClass::getOpaquePointer(*this));
+
+// CHECK:      void CrossModuleDerivedClass::virtualMethodInDerived() {
+// CHECK-NEXT: void ***selfPtr_ = reinterpret_cast<void ***>( ::swift::_impl::_impl_RefCountedClass::getOpaquePointer(*this));
+// CHECK-NEXT: #ifdef __arm64e__
+// CHECK-NEXT: void **vtable_ = ptrauth_auth_data(*selfPtr_, ptrauth_key_process_independent_data, ptrauth_blend_discriminator(selfPtr_,27361));
+// CHECK-NEXT: #else
+// CHECK-NEXT: void **vtable_ = *selfPtr_;
+// CHECK-NEXT: #endif
+// CHECK-NEXT: struct FTypeAddress {
+// CHECK-NEXT: decltype(_impl::$s8UseClass018CrossModuleDerivedB0C015virtualMethodInE0yyF) * func;
+// CHECK-NEXT: };
+// CHECK-NEXT: FTypeAddress *fptrptr_ = reinterpret_cast<FTypeAddress *>(vtable_ + (_impl::$s8UseClass018CrossModuleDerivedB0CMo / sizeof(void *)) + 0);
+// CHECK-NEXT: return (* fptrptr_->func)(::swift::_impl::_impl_RefCountedClass::getOpaquePointer(*this));
+// CHECK-NEXT: }
+
+// CHECK:      swift::Int CrossModuleDerivedClass::getDerivedComputedProp() {
+// CHECK:      FTypeAddress *fptrptr_ = reinterpret_cast<FTypeAddress *>(vtable_ + (_impl::$s8UseClass018CrossModuleDerivedB0CMo / sizeof(void *)) + 1);
+
+// CHECK:      void CrossModuleDerivedClass::virtualMethod2InDerived() {
+// CHECK:      FTypeAddress *fptrptr_ = reinterpret_cast<FTypeAddress *>(vtable_ + (_impl::$s8UseClass018CrossModuleDerivedB0CMo / sizeof(void *)) + 2);
+
+// CHECK:      void CrossModuleDerivedDerivedClass::virtualMethodInDerived() {
+// CHECK:      FTypeAddress *fptrptr_ = reinterpret_cast<FTypeAddress *>(vtable_ + (_impl::$s8UseClass018CrossModuleDerivedB0CMo / sizeof(void *)) + 0);
+
+// CHECK:      swift::Int CrossModuleDerivedDerivedClass::getDerivedComputedProp() {
+// CHECK:      FTypeAddress *fptrptr_ = reinterpret_cast<FTypeAddress *>(vtable_ + (_impl::$s8UseClass018CrossModuleDerivedB0CMo / sizeof(void *)) + 1);
+
+// CHECK:      void CrossModuleDerivedDerivedClass::virtualMethod2InDerived() {
+// CHECK-NEXT: return _impl::$s8UseClass018CrossModuleDerivedeB0C016virtualMethod2InE0yyF(::swift::_impl::_impl_RefCountedClass::getOpaquePointer(*this));
