Merge pull request #63628 from hyp/eng/vtable5

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

Author: hyp

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
     };
@@ -268,44 +271,73 @@ class IRABIDetailsProvider {
     }
 
     static MethodDispatchInfo indirectVTableStaticOffset(
-        size_t bitOffset, Optional<PointerAuthDiscriminator> discriminator) {
-      return MethodDispatchInfo(Kind::IndirectVTableStaticOffset, bitOffset, "",
+        size_t offset, Optional<PointerAuthDiscriminator> discriminator) {
+      return MethodDispatchInfo(Kind::IndirectVTableStaticOffset, offset, "",
                                 discriminator);
     }
 
+    static MethodDispatchInfo indirectVTableRelativeOffset(
+        size_t offset, std::string symbolName,
+        Optional<PointerAuthDiscriminator> discriminator) {
+      return MethodDispatchInfo(Kind::IndirectVTableRelativeOffset, offset,
+                                symbolName, discriminator);
+    }
+
     static MethodDispatchInfo thunk(std::string thunkName) {
       return MethodDispatchInfo(Kind::Thunk, 0, thunkName);
     }
 
     Kind getKind() const { return kind; }
-    size_t getStaticBitOffset() const {
+
+    /// Return the byte offset into the vtable from which the method pointer
+    /// should be loaded.
+    size_t getStaticOffset() const {
       assert(kind == Kind::IndirectVTableStaticOffset);
-      return bitOffset;
+      return offset;
     }
     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 byte offset relative to base offset value into the vtable
+    /// from which the method pointer should be loaded.
+    size_t getRelativeOffset() const {
+      assert(kind == Kind::IndirectVTableRelativeOffset);
+      return offset;
+    }
+
+    /// 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 offset, std::string symbolName = "",
                        Optional<PointerAuthDiscriminator> discriminator = None)
-        : kind(kind), bitOffset(bitOffset), thunkName(thunkName),
+        : kind(kind), offset(offset), symbolName(symbolName),
           discriminator(discriminator) {}
 
     Kind kind;
-    size_t bitOffset;
-    std::string thunkName;
+    size_t offset;
+    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;
 };

lib/IRGen/IRABIDetailsProvider.cpp

@@ -253,14 +253,24 @@ class IRABIDetailsProviderImpl {
     case ClassMetadataLayout::MethodInfo::Kind::Offset:
       if (mi->TheOffset.isStatic()) {
         return MethodDispatchInfo::indirectVTableStaticOffset(
-            /*bitOffset=*/mi->TheOffset.getStaticOffset().getValue(),
+            /*offset=*/mi->TheOffset.getStaticOffset().getValue(),
             getMethodPointerAuthInfo(funcDecl, silDecl));
       }
-      return {};
+      assert(mi->TheOffset.isDynamic());
+      return MethodDispatchInfo::indirectVTableRelativeOffset(
+          /*offset=*/mi->TheOffset.getRelativeOffset().getValue(),
+          /*symbolName=*/
+          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 +480,7 @@ IRABIDetailsProvider::getMethodDispatchInfo(
     const AbstractFunctionDecl *funcDecl) {
   return impl->getMethodDispatchInfo(funcDecl);
 }
+
+Type IRABIDetailsProvider::getClassBaseOffsetSymbolType() const {
+  return impl->getClassBaseOffsetSymbolType();
+}

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "ClangSyntaxPrinter.h"
+#include "PrimitiveTypeMapping.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
@@ -424,3 +425,13 @@ void ClangSyntaxPrinter::printSymbolUSRAttribute(const ValueDecl *D) const {
     return;
   os << " SWIFT_SYMBOL(\"" << result << "\")";
 }
+
+void ClangSyntaxPrinter::printKnownCType(
+    Type t, PrimitiveTypeMapping &typeMapping) const {
+  auto info =
+      typeMapping.getKnownCTypeInfo(t->getNominalOrBoundGenericNominal());
+  assert(info.has_value() && "not a known type");
+  os << info->name;
+  if (info->canBeNullable)
+    os << " _Null_unspecified";
+}

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -13,9 +13,10 @@
 #ifndef SWIFT_PRINTASCLANG_CLANGSYNTAXPRINTER_H
 #define SWIFT_PRINTASCLANG_CLANGSYNTAXPRINTER_H
 
-#include "swift/IRGen/GenericRequirement.h"
+#include "swift/AST/Type.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/IRGen/GenericRequirement.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -25,6 +26,7 @@ class CanGenericSignature;
 class GenericTypeParamType;
 class ModuleDecl;
 class NominalTypeDecl;
+class PrimitiveTypeMapping;
 
 namespace cxx_synthesis {
 
@@ -225,6 +227,9 @@ class ClangSyntaxPrinter {
   /// on the generated declaration.
   void printSymbolUSRAttribute(const ValueDecl *D) const;
 
+  /// Print the given **known** type as a C type.
+  void printKnownCType(Type t, PrimitiveTypeMapping &typeMapping) const;
+
 protected:
   raw_ostream &os;
 };

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";
+              });
         }
       }
     }

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";

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,14 @@ 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->getStaticOffset();
+      else
+        os << '(' << cxx_synthesis::getCxxImplNamespaceName()
+           << "::" << dispatchInfo->getBaseOffsetSymbolName() << " + "
+           << dispatchInfo->getRelativeOffset() << ')';
+      os << " / sizeof(void *));\n";
       indirectFunctionVar = StringRef("fptrptr_->func");
       break;
     case DispatchKindTy::Thunk:

lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp

@@ -23,24 +23,14 @@
 
 using namespace swift;
 
-static void printKnownCType(Type t, PrimitiveTypeMapping &typeMapping,
-                            raw_ostream &os) {
-  auto info =
-      typeMapping.getKnownCTypeInfo(t->getNominalOrBoundGenericNominal());
-  assert(info.has_value() && "not a known type");
-  os << info->name;
-  if (info->canBeNullable)
-    os << " _Null_unspecified";
-}
-
 static void printKnownStruct(
     PrimitiveTypeMapping &typeMapping, raw_ostream &os, StringRef name,
     const IRABIDetailsProvider::TypeRecordABIRepresentation &typeRecord) {
   assert(typeRecord.getMembers().size() > 1);
   os << "struct " << name << " {\n";
   for (const auto &ty : llvm::enumerate(typeRecord.getMembers())) {
     os << "  ";
-    printKnownCType(ty.value(), typeMapping, os);
+    ClangSyntaxPrinter(os).printKnownCType(ty.value(), typeMapping);
     os << " _" << ty.index() << ";\n";
   }
   os << "};\n";
@@ -51,7 +41,8 @@ static void printKnownTypedef(
     const IRABIDetailsProvider::TypeRecordABIRepresentation &typeRecord) {
   assert(typeRecord.getMembers().size() == 1);
   os << "typedef ";
-  printKnownCType(typeRecord.getMembers()[0], typeMapping, os);
+  ClangSyntaxPrinter(os).printKnownCType(typeRecord.getMembers()[0],
+                                         typeMapping);
   os << " " << name << ";\n";
 }