Merge pull request #18334 from rjmccall/foreign-metadata-initialization

Update the ABI for uniquing foreign type metadata

Author: rjmccall

include/swift/ABI/Metadata.h

@@ -1268,6 +1268,10 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
     /// "in-place" code pattern.
     InPlaceMetadataInitialization = 1,
 
+    /// The type requires non-trivial singleton initialization using the
+    /// "foreign" code pattern.
+    ForeignMetadataInitialization = 2,
+
     // We only have two bits here, so if you add a third special kind,
     // include more flag bits in its out-of-line storage.
   };
@@ -1282,6 +1286,10 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
     return getMetadataInitialization() == InPlaceMetadataInitialization;
   }
 
+  bool hasForeignMetadataInitialization() const {
+    return getMetadataInitialization() == ForeignMetadataInitialization;
+  }
+
   enum ImportNamespaceKind {
     /// The type comes the default namespace for its language.
     DefaultNamespace = 0,

include/swift/ABI/MetadataValues.h

@@ -1188,8 +1188,22 @@ class MetadataReader {
     TypeContextDescriptorFlags typeFlags(flags.getKindSpecificFlags());
     unsigned baseSize = 0;
     unsigned genericHeaderSize = sizeof(GenericContextDescriptorHeader);
-    unsigned inPlaceInitSize = 0;
+    unsigned metadataInitSize = 0;
     bool hasVTable = false;
+
+    auto readMetadataInitSize = [&]() -> unsigned {
+      switch (typeFlags.getMetadataInitialization()) {
+      case TypeContextDescriptorFlags::NoMetadataInitialization:
+        return 0;
+      case TypeContextDescriptorFlags::InPlaceMetadataInitialization:
+        // FIXME: classes
+        return sizeof(TargetInPlaceValueMetadataInitialization<Runtime>);
+      case TypeContextDescriptorFlags::ForeignMetadataInitialization:
+        return sizeof(TargetForeignMetadataInitialization<Runtime>);
+      }
+      return 0;
+    };
+
     switch (auto kind = flags.getKind()) {
     case ContextDescriptorKind::Module:
       baseSize = sizeof(TargetModuleContextDescriptor<Runtime>);
@@ -1205,22 +1219,17 @@ class MetadataReader {
       baseSize = sizeof(TargetClassDescriptor<Runtime>);
       genericHeaderSize = sizeof(TypeGenericContextDescriptorHeader);
       hasVTable = typeFlags.class_hasVTable();
+      metadataInitSize = readMetadataInitSize();
       break;
     case ContextDescriptorKind::Enum:
       baseSize = sizeof(TargetEnumDescriptor<Runtime>);
       genericHeaderSize = sizeof(TypeGenericContextDescriptorHeader);
-      if (typeFlags.hasInPlaceMetadataInitialization()) {
-        inPlaceInitSize =
-          sizeof(TargetInPlaceValueMetadataInitialization<Runtime>);
-      }
+      metadataInitSize = readMetadataInitSize();
       break;
     case ContextDescriptorKind::Struct:
       baseSize = sizeof(TargetStructDescriptor<Runtime>);
       genericHeaderSize = sizeof(TypeGenericContextDescriptorHeader);
-      if (typeFlags.hasInPlaceMetadataInitialization()) {
-        inPlaceInitSize =
-          sizeof(TargetInPlaceValueMetadataInitialization<Runtime>);
-      }
+      metadataInitSize = readMetadataInitSize();
       break;
     case ContextDescriptorKind::Protocol:
       baseSize = sizeof(TargetProtocolDescriptorRef<Runtime>);
@@ -1229,7 +1238,7 @@ class MetadataReader {
       // We don't know about this kind of context.
       return nullptr;
     }
-    
+
     // Determine the full size of the descriptor. This is reimplementing a fair
     // bit of TrailingObjects but for out-of-process; maybe there's a way to
     // factor the layout stuff out...
@@ -1256,7 +1265,8 @@ class MetadataReader {
       TargetVTableDescriptorHeader<Runtime> header;
       auto headerAddr = address
         + baseSize
-        + genericsSize;
+        + genericsSize
+        + metadataInitSize;
 
       if (!Reader->readBytes(RemoteAddress(headerAddr),
                              (uint8_t*)&header, sizeof(header)))
@@ -1266,7 +1276,7 @@ class MetadataReader {
         + header.VTableSize * sizeof(TargetMethodDescriptor<Runtime>);
     }
 
-    unsigned size = baseSize + genericsSize + vtableSize + inPlaceInitSize;
+    unsigned size = baseSize + genericsSize + metadataInitSize + vtableSize;
     auto buffer = (uint8_t *)malloc(size);
     if (!Reader->readBytes(RemoteAddress(address), buffer, size)) {
       free(buffer);

include/swift/Remote/MetadataReader.h

@@ -469,9 +469,10 @@ swift_getObjCClassFromObject(HeapObject *object);
 #endif
 
 /// \brief Fetch a unique type metadata object for a foreign type.
-SWIFT_RUNTIME_EXPORT
-const ForeignTypeMetadata *
-swift_getForeignTypeMetadata(ForeignTypeMetadata *nonUnique);
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse
+swift_getForeignTypeMetadata(MetadataRequest request,
+                             ForeignTypeMetadata *nonUnique);
 
 /// \brief Fetch a unique witness table for a foreign witness table.
 SWIFT_RUNTIME_EXPORT

include/swift/Runtime/Metadata.h

@@ -638,9 +638,9 @@ FUNCTION(GetFunctionMetadata3, swift_getFunctionTypeMetadata3,
         ATTRS(NoUnwind, ReadNone))
 
 // Metadata *swift_getForeignTypeMetadata(Metadata *nonUnique);
-FUNCTION(GetForeignTypeMetadata, swift_getForeignTypeMetadata, C_CC,
-         RETURNS(TypeMetadataPtrTy),
-         ARGS(TypeMetadataPtrTy),
+FUNCTION(GetForeignTypeMetadata, swift_getForeignTypeMetadata, SwiftCC,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy, TypeMetadataPtrTy),
          ATTRS(NoUnwind, ReadNone)) // only writes to runtime-private fields
 
 // WitnessTable *swift_getForeignWitnessTable(

include/swift/Runtime/RuntimeFunctions.def

@@ -37,16 +37,8 @@ class ForeignClassMetadataVisitor
   void layout() {
     super::layout();
     asImpl().addNominalTypeDescriptor();
-    asImpl().noteStartOfSuperClass();
     asImpl().addSuperclass();
     asImpl().addReservedWord();
-    asImpl().addReservedWord();
-    asImpl().addReservedWord();
-  }
-
-  bool requiresInitializationFunction() {
-    return Target->getSuperclassDecl() &&
-           Target->getSuperclassDecl()->isForeign();
   }
 
   CanType getTargetType() const {

lib/IRGen/ForeignClassMetadataVisitor.h

@@ -1488,8 +1488,7 @@ SILLinkage LinkEntity::getLinkage(ForDefinition_t forDefinition) const {
       return getSILLinkage(FormalLinkage::PublicUnique, forDefinition);
 
     // Imported types.
-    if (getTypeMetadataAccessStrategy(type) ==
-          MetadataAccessStrategy::NonUniqueAccessor)
+    if (isAccessorLazilyGenerated(getTypeMetadataAccessStrategy(type)))
       return SILLinkage::Shared;
 
     // Everything else is only referenced inside its module.
@@ -1507,8 +1506,7 @@ SILLinkage LinkEntity::getLinkage(ForDefinition_t forDefinition) const {
     auto type = getType();
 
     // Imported types, non-primitive structural types.
-    if (getTypeMetadataAccessStrategy(type) ==
-          MetadataAccessStrategy::NonUniqueAccessor)
+    if (isAccessorLazilyGenerated(getTypeMetadataAccessStrategy(type)))
       return SILLinkage::Shared;
 
     // Everything else is only referenced inside its module.
@@ -1548,6 +1546,7 @@ SILLinkage LinkEntity::getLinkage(ForDefinition_t forDefinition) const {
       return getSILLinkage(FormalLinkage::HiddenUnique, forDefinition);
     case MetadataAccessStrategy::PrivateAccessor:
       return getSILLinkage(FormalLinkage::Private, forDefinition);
+    case MetadataAccessStrategy::ForeignAccessor:
     case MetadataAccessStrategy::NonUniqueAccessor:
       return SILLinkage::Shared;
     }