Implement dependent layouts for raw types

Azoy · Azoy · commit df17f7be9016 · 2023-08-01T14:09:23.000-07:00
Update raw_layout.swift

Allow for concrete specializations of raw layout

Make test platform agnostic
diff --git a/include/swift/Runtime/Metadata.h b/include/swift/Runtime/Metadata.h
@@ -1038,6 +1038,14 @@ SWIFT_RUNTIME_STDLIB_SPI
 void _swift_registerConcurrencyStandardTypeDescriptors(
     const ConcurrencyStandardTypeDescriptors *descriptors);
 
+/// Initialize the value witness table for a struct using the provided like type
+/// as the basis for the layout.
+SWIFT_RUNTIME_EXPORT
+void swift_initRawStructMetadata(StructMetadata *self,
+                                 StructLayoutFlags flags,
+                                 const TypeLayout *likeType,
+                                 size_t count);
+
 #pragma clang diagnostic pop
 
 } // end namespace swift
diff --git a/include/swift/Runtime/RuntimeFunctions.def b/include/swift/Runtime/RuntimeFunctions.def
@@ -2486,6 +2486,18 @@ FUNCTION(GenericInstantiateLayoutString,
          ATTRS(NoUnwind),
          EFFECT(MetaData))
 
+// void swift_initRawStructMetadata(Metadata *structType,
+//                                  StructLayoutFlags flags,
+//                                  const TypeLayout *likeType,
+//                                  size_t count);
+FUNCTION(InitRawStructMetadata,
+         swift_initRawStructMetadata,
+         C_CC, AlwaysAvailable,
+         RETURNS(VoidTy),
+         ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy->getPointerTo(0), SizeTy),
+         ATTRS(NoUnwind),
+         EFFECT(MetaData))
+
 #undef RETURNS
 #undef ARGS
 #undef ATTRS
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
@@ -134,8 +134,8 @@ AsyncContextLayout::AsyncContextLayout(
     IRGenModule &IGM, LayoutStrategy strategy, ArrayRef<SILType> fieldTypes,
     ArrayRef<const TypeInfo *> fieldTypeInfos, CanSILFunctionType originalType,
     CanSILFunctionType substitutedType, SubstitutionMap substitutionMap)
-    : StructLayout(IGM, /*decl=*/nullptr, LayoutKind::NonHeapObject, strategy,
-                   fieldTypeInfos, /*typeToFill*/ nullptr),
+    : StructLayout(IGM, /*type=*/ llvm::None, LayoutKind::NonHeapObject,
+                   strategy, fieldTypeInfos, /*typeToFill*/ nullptr),
       originalType(originalType), substitutedType(substitutedType),
       substitutionMap(substitutionMap)  {
   assert(fieldTypeInfos.size() == fieldTypes.size() &&
diff --git a/lib/IRGen/GenDiffFunc.cpp b/lib/IRGen/GenDiffFunc.cpp
@@ -211,7 +211,7 @@ class DifferentiableFuncTypeBuilder
   }
 
   StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {
-    return StructLayout(IGM, /*decl=*/nullptr, LayoutKind::NonHeapObject,
+    return StructLayout(IGM, /*type=*/ llvm::None, LayoutKind::NonHeapObject,
                         LayoutStrategy::Universal, fieldTypes);
   }
 };
@@ -383,7 +383,7 @@ class LinearFuncTypeBuilder
   }
 
   StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {
-    return StructLayout(IGM, /*decl=*/nullptr, LayoutKind::NonHeapObject,
+    return StructLayout(IGM, /*type=*/ llvm::None, LayoutKind::NonHeapObject,
                         LayoutStrategy::Universal, fieldTypes);
   }
 };
diff --git a/lib/IRGen/GenHeap.cpp b/lib/IRGen/GenHeap.cpp
@@ -274,7 +274,7 @@ HeapLayout::HeapLayout(IRGenModule &IGM, LayoutStrategy strategy,
                        ArrayRef<const TypeInfo *> fieldTypeInfos,
                        llvm::StructType *typeToFill,
                        NecessaryBindings &&bindings, unsigned bindingsIndex)
-    : StructLayout(IGM, /*decl=*/nullptr, LayoutKind::HeapObject, strategy,
+    : StructLayout(IGM, /*type=*/ llvm::None, LayoutKind::HeapObject, strategy,
                    fieldTypeInfos, typeToFill),
       ElementTypes(fieldTypes.begin(), fieldTypes.end()),
       Bindings(std::move(bindings)), BindingsIndex(bindingsIndex) {
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -2983,6 +2983,20 @@ static void emitInitializeFieldOffsetVectorWithLayoutString(
                                 IGM.getPointerSize() * numFields);
 }
 
+static void emitInitializeRawLayout(IRGenFunction &IGF, SILType likeType,
+                                    Size count, SILType T,
+                                    llvm::Value *metadata,
+                                    MetadataDependencyCollector *collector) {
+  auto &IGM = IGF.IGM;
+  auto likeTypeLayout = emitTypeLayoutRef(IGF, likeType, collector);
+  StructLayoutFlags flags = StructLayoutFlags::Swift5Algorithm;
+
+  // Call swift_initRawStructMetadata().
+  IGF.Builder.CreateCall(IGM.getInitRawStructMetadataFunctionPointer(),
+                         {metadata, IGM.getSize(Size(uintptr_t(flags))),
+                          likeTypeLayout, IGM.getSize(count)});
+}
+
 static void emitInitializeValueMetadata(IRGenFunction &IGF,
                                         NominalTypeDecl *nominalDecl,
                                         llvm::Value *metadata,
@@ -2996,10 +3010,34 @@ static void emitInitializeValueMetadata(IRGenFunction &IGF,
         IGM.getOptions().EnableLayoutStringValueWitnesses &&
         IGM.getOptions().EnableLayoutStringValueWitnessesInstantiation;
 
-  if (isa<StructDecl>(nominalDecl)) {
+  if (auto sd = dyn_cast<StructDecl>(nominalDecl)) {
     auto &fixedTI = IGM.getTypeInfo(loweredTy);
     if (isa<FixedTypeInfo>(fixedTI)) return;
 
+    // Use a different runtime function to initialize the value witness table
+    // if the struct has a raw layout. The existing swift_initStructMetadata
+    // is the wrong thing for these types.
+    if (auto rawLayout = nominalDecl->getAttrs().getAttribute<RawLayoutAttr>()) {
+      SILType loweredLikeType;
+      Size count;
+
+      if (auto likeType = rawLayout->getResolvedScalarLikeType(sd)) {
+        loweredLikeType = IGM.getLoweredType(AbstractionPattern::getOpaque(),
+                                             *likeType);
+        count = Size(-1);
+      } else if (auto likeArray = rawLayout->getResolvedArrayLikeTypeAndCount(sd)) {
+        auto likeType = likeArray->first;
+        loweredLikeType = IGM.getLoweredType(AbstractionPattern::getOpaque(),
+                                             likeType);
+
+        count = Size(likeArray->second);
+      }
+
+      emitInitializeRawLayout(IGF, loweredLikeType, count, loweredTy, metadata,
+                              collector);
+      return;
+    }
+
     if (useLayoutStrings) {
       emitInitializeFieldOffsetVectorWithLayoutString(IGF, loweredTy, metadata,
                                                       isVWTMutable, collector);
diff --git a/lib/IRGen/GenRecord.h b/lib/IRGen/GenRecord.h
@@ -863,7 +863,6 @@ class RecordTypeBuilder {
     fields.reserve(astFields.size());
     fieldTypesForLayout.reserve(astFields.size());
 
-    bool loadable = true;
     auto fieldsABIAccessible = FieldsAreABIAccessible;
 
     unsigned explosionSize = 0;
@@ -880,7 +879,6 @@ class RecordTypeBuilder {
 
       auto loadableFieldTI = dyn_cast<LoadableTypeInfo>(&fieldTI);
       if (!loadableFieldTI) {
-        loadable = false;
         continue;
       }
 
@@ -902,7 +900,7 @@ class RecordTypeBuilder {
     }
 
     // Create the type info.
-    if (loadable) {
+    if (layout.isLoadable()) {
       assert(layout.isFixedLayout());
       assert(fieldsABIAccessible);
       return asImpl()->createLoadable(fields, std::move(layout), explosionSize);
diff --git a/lib/IRGen/GenStruct.cpp b/lib/IRGen/GenStruct.cpp
@@ -1088,6 +1088,35 @@ namespace {
         fields.push_back(
             field.getTypeInfo().buildTypeLayoutEntry(IGM, fieldTy, useStructLayouts));
       }
+
+      auto decl = T.getASTType()->getStructOrBoundGenericStruct();
+      auto rawLayout = decl->getAttrs().getAttribute<RawLayoutAttr>();
+
+      // If we have a raw layout struct who is non-fixed size, it means the
+      // layout of the struct is dependent on the archetype of the thing it's
+      // like.
+      if (rawLayout) {
+        SILType loweredLikeType;
+
+        if (auto likeType = rawLayout->getResolvedScalarLikeType(decl)) {
+          loweredLikeType = IGM.getLoweredType(*likeType);
+        } else if (auto likeArray = rawLayout->getResolvedArrayLikeTypeAndCount(decl)) {
+          loweredLikeType = IGM.getLoweredType(likeArray->first);
+        }
+
+        // The given struct type T that we're building may be in a generic
+        // environment that is different than that which was built our
+        // resolved rawLayout like type. Map our like type into the given
+        // environment.
+        auto subs = T.getASTType()->getContextSubstitutionMap(
+          IGM.getSwiftModule(), decl);
+
+        loweredLikeType = loweredLikeType.subst(IGM.getSILModule(), subs);
+
+        return IGM.getTypeInfo(loweredLikeType).buildTypeLayoutEntry(IGM,
+          loweredLikeType, useStructLayouts);
+      }
+
       assert(!fields.empty() &&
              "Empty structs should not be NonFixedStructTypeInfo");
 
@@ -1244,8 +1273,7 @@ namespace {
     }
 
     StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {
-      return StructLayout(IGM, TheStruct->getAnyNominal(),
-                          LayoutKind::NonHeapObject,
+      return StructLayout(IGM, TheStruct, LayoutKind::NonHeapObject,
                           LayoutStrategy::Optimal, fieldTypes, StructTy);
     }
   };
diff --git a/lib/IRGen/GenTuple.cpp b/lib/IRGen/GenTuple.cpp
@@ -512,7 +512,7 @@ namespace {
     }
 
     StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {
-      return StructLayout(IGM, /*decl=*/nullptr, LayoutKind::NonHeapObject,
+      return StructLayout(IGM, /*type=*/ llvm::None, LayoutKind::NonHeapObject,
                           LayoutStrategy::Universal, fieldTypes);
     }
   };
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -2437,6 +2437,17 @@ namespace {
       if (IGM.isResilient(decl, ResilienceExpansion::Maximal))
         return true;
 
+      auto rawLayout = decl->getAttrs().getAttribute<RawLayoutAttr>();
+
+      // If our struct has a raw layout, it may be dependent on the like type.
+      if (rawLayout) {
+        if (auto likeType = rawLayout->getResolvedScalarLikeType(decl)) {
+          return visit((*likeType)->getCanonicalType());
+        } else if (auto likeArray = rawLayout->getResolvedArrayLikeTypeAndCount(decl)) {
+          return visit(likeArray->first->getCanonicalType());
+        }
+      }
+
       for (auto field : decl->getStoredProperties()) {
         if (visit(field->getInterfaceType()->getCanonicalType()))
           return true;
diff --git a/lib/IRGen/StructLayout.cpp b/lib/IRGen/StructLayout.cpp
@@ -43,11 +43,17 @@ static bool requiresHeapHeader(LayoutKind kind) {
 
 /// Perform structure layout on the given types.
 StructLayout::StructLayout(IRGenModule &IGM,
-                           NominalTypeDecl *decl,
+                           llvm::Optional<CanType> type,
                            LayoutKind layoutKind,
                            LayoutStrategy strategy,
                            ArrayRef<const TypeInfo *> types,
                            llvm::StructType *typeToFill) {
+  NominalTypeDecl *decl = nullptr;
+
+  if (type) {
+    decl = type->getAnyNominal();
+  }
+
   Elements.reserve(types.size());
 
   // Fill in the Elements array.
@@ -73,7 +79,7 @@ StructLayout::StructLayout(IRGenModule &IGM,
   if (decl) {
     rawLayout = decl->getAttrs().getAttribute<RawLayoutAttr>();
   }
-  if (rawLayout) {
+  if (rawLayout && type) {
     auto sd = cast<StructDecl>(decl);
     IsKnownTriviallyDestroyable = deinit;
     IsKnownBitwiseTakable = IsBitwiseTakable;
@@ -82,6 +88,7 @@ StructLayout::StructLayout(IRGenModule &IGM,
     IsKnownCopyable = copyable;
     assert(builder.getHeaderSize() == Size(0));
     headerSize = Size(0);
+    IsLoadable = false;
 
     auto &Diags = IGM.Context.Diags;
     // Fixed size and alignment specified.
@@ -100,9 +107,12 @@ StructLayout::StructLayout(IRGenModule &IGM,
       IsFixedLayout = true;
       IsKnownAlwaysFixedSize = IsFixedSize;
     } else if (auto likeType = rawLayout->getResolvedScalarLikeType(sd)) {
-      const TypeInfo &likeTypeInfo
-        = IGM.getTypeInfoForUnlowered(AbstractionPattern::getOpaque(),
-                                      *likeType);
+      // If our likeType is dependent, then all calls to try and lay it out will
+      // be non-fixed, but in a concrete case we want a fixed layout, so try to
+      // substitute it out.
+      auto subs = (*type)->getContextSubstitutionMap(IGM.getSwiftModule(), decl);
+      auto loweredLikeType = IGM.getLoweredType(likeType->subst(subs));
+      const TypeInfo &likeTypeInfo = IGM.getTypeInfo(loweredLikeType);
                                       
       // Take layout attributes from the like type.
       if (const FixedTypeInfo *likeFixedType = dyn_cast<FixedTypeInfo>(&likeTypeInfo)) {
@@ -121,9 +131,9 @@ StructLayout::StructLayout(IRGenModule &IGM,
       auto elementType = likeArray->first;
       unsigned count = likeArray->second;
       
-      const TypeInfo &likeTypeInfo
-        = IGM.getTypeInfoForUnlowered(AbstractionPattern::getOpaque(),
-                                      elementType);
+      auto subs = (*type)->getContextSubstitutionMap(IGM.getSwiftModule(), decl);
+      auto loweredElementType = IGM.getLoweredType(elementType.subst(subs));
+      const TypeInfo &likeTypeInfo = IGM.getTypeInfo(loweredElementType);
       
       // Take layout attributes from the like type.
       if (const FixedTypeInfo *likeFixedType = dyn_cast<FixedTypeInfo>(&likeTypeInfo)) {
@@ -155,11 +165,6 @@ StructLayout::StructLayout(IRGenModule &IGM,
       }
     } else {
       Ty = (typeToFill ? typeToFill : IGM.OpaqueTy);
-      
-      // TODO: For types with dependent layout, the metadata initialization also
-      // has to be updated to account for the raw layout description.
-      Diags.diagnose(rawLayout->getLocation(),
-                     diag::raw_layout_dynamic_type_layout_unsupported);
     }
   } else {
     bool nonEmpty = builder.addFields(Elements, strategy);
@@ -174,6 +179,7 @@ StructLayout::StructLayout(IRGenModule &IGM,
       headerSize = builder.getHeaderSize();
       SpareBits.clear();
       IsFixedLayout = true;
+      IsLoadable = true;
       IsKnownTriviallyDestroyable = deinit;
       IsKnownBitwiseTakable = IsBitwiseTakable;
       IsKnownAlwaysFixedSize = IsFixedSize;
@@ -185,6 +191,7 @@ StructLayout::StructLayout(IRGenModule &IGM,
       headerSize = builder.getHeaderSize();
       SpareBits = builder.getSpareBits();
       IsFixedLayout = builder.isFixedLayout();
+      IsLoadable = builder.isLoadable();
       IsKnownTriviallyDestroyable = deinit & builder.isTriviallyDestroyable();
       IsKnownBitwiseTakable = builder.isBitwiseTakable();
       IsKnownAlwaysFixedSize = builder.isAlwaysFixedSize();
@@ -379,6 +386,7 @@ bool StructLayoutBuilder::addField(ElementLayout &elt,
   IsKnownTriviallyDestroyable &= eltTI.isTriviallyDestroyable(ResilienceExpansion::Maximal);
   IsKnownBitwiseTakable &= eltTI.isBitwiseTakable(ResilienceExpansion::Maximal);
   IsKnownAlwaysFixedSize &= eltTI.isFixedSize(ResilienceExpansion::Minimal);
+  IsLoadable &= eltTI.isLoadable();
 
   if (eltTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
     addEmptyElement(elt);
diff --git a/lib/IRGen/StructLayout.h b/lib/IRGen/StructLayout.h
@@ -283,6 +283,7 @@ class StructLayoutBuilder {
   SmallVector<SpareBitVector, 8> CurSpareBits;
   unsigned NextNonFixedOffsetIndex = 0;
   bool IsFixedLayout = true;
+  bool IsLoadable = true;
   IsTriviallyDestroyable_t IsKnownTriviallyDestroyable = IsTriviallyDestroyable;
   IsBitwiseTakable_t IsKnownBitwiseTakable = IsBitwiseTakable;
   IsCopyable_t IsKnownCopyable = IsCopyable;
@@ -327,6 +328,9 @@ class StructLayoutBuilder {
   /// Return whether the structure has a fixed-size layout.
   bool isFixedLayout() const { return IsFixedLayout; }
 
+  /// Return whether the structure has a loadable layout.
+  bool isLoadable() const { return IsLoadable; }
+
   /// Return whether the structure is known to be POD in the local
   /// resilience scope.
   IsTriviallyDestroyable_t isTriviallyDestroyable() const { return IsKnownTriviallyDestroyable; }
@@ -402,6 +406,9 @@ class StructLayout {
   /// alignment are exact.
   bool IsFixedLayout;
 
+  /// Whether this layout 
+  bool IsLoadable;
+
   IsTriviallyDestroyable_t IsKnownTriviallyDestroyable;
   IsBitwiseTakable_t IsKnownBitwiseTakable;
   IsCopyable_t IsKnownCopyable;
@@ -419,7 +426,7 @@ class StructLayout {
   ///   layout must include the reference-counting header
   /// \param typeToFill - if present, must be an opaque type whose body
   ///   will be filled with this layout
-  StructLayout(IRGenModule &IGM, NominalTypeDecl *decl,
+  StructLayout(IRGenModule &IGM, llvm::Optional<CanType> type,
                LayoutKind kind, LayoutStrategy strategy,
                ArrayRef<const TypeInfo *> fields,
                llvm::StructType *typeToFill = 0);
@@ -434,6 +441,7 @@ class StructLayout {
       headerSize(builder.getHeaderSize()),
       SpareBits(builder.getSpareBits()),
       IsFixedLayout(builder.isFixedLayout()),
+      IsLoadable(builder.isLoadable()),
       IsKnownTriviallyDestroyable(builder.isTriviallyDestroyable()),
       IsKnownBitwiseTakable(builder.isBitwiseTakable()),
       IsKnownCopyable(builder.isCopyable()),
@@ -467,6 +475,7 @@ class StructLayout {
   }
 
   bool isFixedLayout() const { return IsFixedLayout; }
+  bool isLoadable() const { return IsLoadable; }
   llvm::Constant *emitSize(IRGenModule &IGM) const;
   llvm::Constant *emitAlignMask(IRGenModule &IGM) const;
 
diff --git a/stdlib/public/runtime/Metadata.cpp b/stdlib/public/runtime/Metadata.cpp
diff --git a/test/IRGen/raw_layout.swift b/test/IRGen/raw_layout.swift
diff --git a/test/Interpreter/raw_layout.swift b/test/Interpreter/raw_layout.swift
diff --git a/test/Sema/raw_layout.swift b/test/Sema/raw_layout.swift

Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ class DifferentiableFuncTypeBuilder`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {`
`214`		`- return StructLayout(IGM, /decl=/nullptr, LayoutKind::NonHeapObject,`
	`214`	`+ return StructLayout(IGM, /type=/ llvm::None, LayoutKind::NonHeapObject,`
`215`	`215`	`LayoutStrategy::Universal, fieldTypes);`
`216`	`216`	`}`
`217`	`217`	`};`
`@@ -383,7 +383,7 @@ class LinearFuncTypeBuilder`
`383`	`383`	`}`
`384`	`384`
`385`	`385`	`StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {`
`386`		`- return StructLayout(IGM, /decl=/nullptr, LayoutKind::NonHeapObject,`
	`386`	`+ return StructLayout(IGM, /type=/ llvm::None, LayoutKind::NonHeapObject,`
`387`	`387`	`LayoutStrategy::Universal, fieldTypes);`
`388`	`388`	`}`
`389`	`389`	`};`
Original file line number	Diff line number	Diff line change
`@@ -512,7 +512,7 @@ namespace {`
`512`	`512`	`}`
`513`	`513`
`514`	`514`	`StructLayout performLayout(ArrayRef<const TypeInfo *> fieldTypes) {`
`515`		`- return StructLayout(IGM, /decl=/nullptr, LayoutKind::NonHeapObject,`
	`515`	`+ return StructLayout(IGM, /type=/ llvm::None, LayoutKind::NonHeapObject,`
`516`	`516`	`LayoutStrategy::Universal, fieldTypes);`
`517`	`517`	`}`
`518`	`518`	`};`