Merge pull request #70720 from nate-chandler/rdar119829826

[IRGen] Pack metadata may be allocated based on type layouts.

Author: nate-chandler

include/swift/SIL/SILInstruction.h

@@ -853,7 +853,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
 
   /// Whether IRGen lowering of this instruction may result in emitting packs of
   /// metadata or witness tables.
-  bool mayRequirePackMetadata() const;
+  bool mayRequirePackMetadata(SILFunction const &F) const;
 
   /// Create a new copy of this instruction, which retains all of the operands
   /// and other information of this one.  If an insertion point is specified,

include/swift/SIL/SILType.h

@@ -395,6 +395,9 @@ class SILType {
   /// Whether the type contains any flavor of pack.
   bool hasAnyPack() const { return getASTType()->hasAnyPack(); }
 
+  /// Whether the type's layout is known to include some flavor of pack.
+  bool isOrContainsPack(const SILFunction &F) const;
+
   /// True if the type is an empty tuple or an empty struct or a tuple or
   /// struct containing only empty types.
   bool isEmpty(const SILFunction &F) const;

include/swift/SIL/TypeLowering.h

@@ -176,6 +176,12 @@ enum IsLexical_t : bool {
   IsLexical = true,
 };
 
+/// Does this type contain any pack-like thing.
+enum HasPack_t : bool {
+  HasNoPack = false,
+  HasPack = true,
+};
+
 /// Extended type information used by SIL.
 class TypeLowering {
 public:
@@ -192,10 +198,12 @@ class TypeLowering {
       InfiniteFlag               = 1 << 5,
       HasRawPointerFlag          = 1 << 6,
       LexicalFlag                = 1 << 7,
+      HasPackFlag                = 1 << 8,
     };
     // clang-format on
 
-    uint8_t Flags;
+    uint16_t Flags;
+
   public:
     /// Construct a default RecursiveProperties, which corresponds to
     /// a trivial, loadable, fixed-layout type.
@@ -207,14 +215,15 @@ class TypeLowering {
         IsTypeExpansionSensitive_t isTypeExpansionSensitive =
             IsNotTypeExpansionSensitive,
         HasRawPointer_t hasRawPointer = DoesNotHaveRawPointer,
-        IsLexical_t isLexical = IsNotLexical)
+        IsLexical_t isLexical = IsNotLexical, HasPack_t hasPack = HasNoPack)
         : Flags((isTrivial ? 0U : NonTrivialFlag) |
                 (isFixedABI ? 0U : NonFixedABIFlag) |
                 (isAddressOnly ? AddressOnlyFlag : 0U) |
                 (isResilient ? ResilientFlag : 0U) |
                 (isTypeExpansionSensitive ? TypeExpansionSensitiveFlag : 0U) |
                 (hasRawPointer ? HasRawPointerFlag : 0U) |
-                (isLexical ? LexicalFlag : 0U)) {}
+                (isLexical ? LexicalFlag : 0U) |
+                (hasPack ? HasPackFlag : 0U)) {}
 
     constexpr bool operator==(RecursiveProperties p) const {
       return Flags == p.Flags;
@@ -236,7 +245,7 @@ class TypeLowering {
 
     static constexpr RecursiveProperties forOpaque() {
       return {IsNotTrivial, IsNotFixedABI, IsAddressOnly, IsNotResilient,
-              IsNotTypeExpansionSensitive, DoesNotHaveRawPointer, IsLexical};
+              IsNotTypeExpansionSensitive, DoesNotHaveRawPointer, IsLexical, HasNoPack};
     }
 
     static constexpr RecursiveProperties forResilient() {
@@ -272,6 +281,9 @@ class TypeLowering {
     IsLexical_t isLexical() const {
       return IsLexical_t((Flags & LexicalFlag) != 0);
     }
+    HasPack_t isOrContainsPack() const {
+      return HasPack_t((Flags & HasPackFlag) != 0);
+    }
 
     void setNonTrivial() { Flags |= NonTrivialFlag; }
     void setNonFixedABI() { Flags |= NonFixedABIFlag; }
@@ -285,6 +297,7 @@ class TypeLowering {
     void setLexical(IsLexical_t isLexical) {
       Flags = (Flags & ~LexicalFlag) | (isLexical ? LexicalFlag : 0);
     }
+    void setHasPack() { Flags |= HasPackFlag; }
   };
 
 private:
@@ -395,6 +408,11 @@ class TypeLowering {
     return Properties.isLexical();
   }
 
+  /// Does this type feature a pack at some level of its type tree.
+  bool isOrContainsPack() const {
+    return Properties.isOrContainsPack();
+  }
+
   ResilienceExpansion getResilienceExpansion() const {
     return expansionContext.getResilienceExpansion();
   }

lib/IRGen/PackMetadataMarkerInserter.cpp

@@ -94,7 +94,9 @@ Inserter::shouldInsertMarkersForInstruction(SILInstruction *inst) {
     LLVM_FALLTHROUGH;
   }
   default:
-    return inst->mayRequirePackMetadata() ? FindResult::Some : FindResult::None;
+    return inst->mayRequirePackMetadata(*inst->getFunction())
+               ? FindResult::Some
+               : FindResult::None;
   }
 }
 

lib/SIL/IR/SILInstruction.cpp

@@ -1301,7 +1301,11 @@ bool SILInstruction::isDeallocatingStack() const {
   return false;
 }
 
-bool SILInstruction::mayRequirePackMetadata() const {
+static bool typeOrLayoutInvolvesPack(SILType ty, SILFunction const &F) {
+  return ty.hasAnyPack() || ty.isOrContainsPack(F);
+}
+
+bool SILInstruction::mayRequirePackMetadata(SILFunction const &F) const {
   switch (getKind()) {
   case SILInstructionKind::AllocPackInst:
   case SILInstructionKind::TuplePackElementAddrInst:
@@ -1313,11 +1317,11 @@ bool SILInstruction::mayRequirePackMetadata() const {
   case SILInstructionKind::TryApplyInst: {
     // Check the function type for packs.
     auto apply = ApplySite::isa(const_cast<SILInstruction *>(this));
-    if (apply.getCallee()->getType().hasAnyPack())
+    if (typeOrLayoutInvolvesPack(apply.getCallee()->getType(), F))
       return true;
     // Check the substituted types for packs.
     for (auto ty : apply.getSubstitutionMap().getReplacementTypes()) {
-      if (ty->hasAnyPack())
+      if (typeOrLayoutInvolvesPack(F.getTypeLowering(ty).getLoweredType(), F))
         return true;
     }
     return false;
@@ -1328,20 +1332,20 @@ bool SILInstruction::mayRequirePackMetadata() const {
   case SILInstructionKind::DestroyValueInst:
   // Unary instructions.
   {
-    return getOperand(0)->getType().hasAnyPack();
+    return typeOrLayoutInvolvesPack(getOperand(0)->getType(), F);
   }
   case SILInstructionKind::AllocStackInst: {
     auto *asi = cast<AllocStackInst>(this);
-    return asi->getType().hasAnyPack();
+    return typeOrLayoutInvolvesPack(asi->getType(), F);
   }
   case SILInstructionKind::MetatypeInst: {
     auto *mi = cast<MetatypeInst>(this);
-    return mi->getType().hasAnyPack();
+    return typeOrLayoutInvolvesPack(mi->getType(), F);
   }
   case SILInstructionKind::WitnessMethodInst: {
     auto *wmi = cast<WitnessMethodInst>(this);
     auto ty = wmi->getLookupType();
-    return ty->hasAnyPack();
+    return typeOrLayoutInvolvesPack(F.getTypeLowering(ty).getLoweredType(), F);
   }
   default:
     // Instructions that deallocate stack must not result in pack metadata
@@ -1359,15 +1363,15 @@ bool SILInstruction::mayRequirePackMetadata() const {
     // Check results and operands for packs.  If a pack appears, lowering the
     // instruction might result in pack metadata emission.
     for (auto result : getResults()) {
-      if (result->getType().hasAnyPack())
+      if (typeOrLayoutInvolvesPack(result->getType(), F))
         return true;
     }
     for (auto operandTy : getOperandTypes()) {
-      if (operandTy.hasAnyPack())
+      if (typeOrLayoutInvolvesPack(operandTy, F))
         return true;
     }
     for (auto &tdo : getTypeDependentOperands()) {
-      if (tdo.get()->getType().hasAnyPack())
+      if (typeOrLayoutInvolvesPack(tdo.get()->getType(), F))
         return true;
     }
 

lib/SIL/IR/SILType.cpp

@@ -128,6 +128,11 @@ bool SILType::isNonTrivialOrContainsRawPointer(const SILFunction *f) const {
   return result;
 }
 
+bool SILType::isOrContainsPack(const SILFunction &F) const {
+  auto contextType = hasTypeParameter() ? F.mapTypeIntoContext(*this) : *this;
+  return F.getTypeLowering(contextType).isOrContainsPack();
+}
+
 bool SILType::isEmpty(const SILFunction &F) const {
   // Infinite types are never empty.
   if (F.getTypeLowering(*this).getRecursiveProperties().isInfinite()) {

lib/SIL/IR/TypeLowering.cpp

@@ -31,6 +31,7 @@
 #include "swift/AST/TypeDifferenceVisitor.h"
 #include "swift/AST/Types.h"
 #include "swift/ClangImporter/ClangModule.h"
+#include "swift/SIL/AbstractionPatternGenerators.h"
 #include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
@@ -261,6 +262,13 @@ namespace {
       return props;
     }
 
+    RecursiveProperties mergeHasPack(HasPack_t hasPack,
+                                     RecursiveProperties props) {
+      if (hasPack == HasPack)
+        props.setHasPack();
+      return props;
+    }
+
     RecursiveProperties applyLifetimeAnnotation(LifetimeAnnotation annotation,
                                                 RecursiveProperties props) {
       switch (annotation) {
@@ -333,7 +341,8 @@ namespace {
                                                IsAddressOnly, IsNotResilient,
                                                isSensitive,
                                                DoesNotHaveRawPointer,
-                                               IsLexical});
+                                               IsLexical,
+                                               HasPack});
     }
 
     RetTy visitSILPackType(CanSILPackType type,
@@ -343,7 +352,8 @@ namespace {
                                                IsAddressOnly, IsNotResilient,
                                                isSensitive,
                                                DoesNotHaveRawPointer,
-                                               IsLexical});
+                                               IsLexical,
+                                               HasPack});
     }
 
     RetTy visitPackExpansionType(CanPackExpansionType type,
@@ -355,6 +365,7 @@ namespace {
                                       type.getPatternType(),
                                       TC, Expansion));
       props = mergeIsTypeExpansionSensitive(isSensitive, props);
+      props.setHasPack();
       return asImpl().handleAddressOnly(type, props);
     }
 
@@ -2252,6 +2263,7 @@ namespace {
                                    IsTypeExpansionSensitive_t isSensitive) {
       RecursiveProperties properties;
       properties.setAddressOnly();
+      properties.setHasPack();
       for (auto i : indices(packType.getElementTypes())) {
         auto &eltLowering =
           TC.getTypeLowering(packType->getSILElementType(i),
@@ -2268,6 +2280,7 @@ namespace {
                                          IsTypeExpansionSensitive_t isSensitive) {
       RecursiveProperties properties;
       properties.setAddressOnly();
+      properties.setHasPack();
       auto &patternLowering =
         TC.getTypeLowering(origType.getPackExpansionPatternType(),
                            packExpansionType.getPatternType(),
@@ -2362,7 +2375,19 @@ namespace {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
       }
-      
+
+      // [is_or_contains_pack_unsubstituted] Visit the fields of the
+      // unsubstituted type to find pack types which would be substituted away.
+      for (auto field : D->getStoredProperties()) {
+        auto fieldInterfaceTy = field->getInterfaceType()->getCanonicalType();
+        auto origFieldType = AbstractionPattern(
+            D->getGenericSignature().getCanonicalSignature(), fieldInterfaceTy);
+        auto fieldProperties =
+            classifyType(origFieldType, fieldInterfaceTy, TC, Expansion);
+        properties =
+            mergeHasPack(fieldProperties.isOrContainsPack(), properties);
+      }
+
       // If the type has raw storage, it is move-only and address-only.
       if (D->getAttrs().hasAttribute<RawLayoutAttr>()) {
         properties.setAddressOnly();
@@ -2442,6 +2467,19 @@ namespace {
       if (handleResilience(enumType, D, properties))
         return handleAddressOnly(enumType, properties);
 
+      // [is_or_contains_pack_unsubstituted] Visit the elements of the
+      // unsubstituted type to find pack types which would be substituted away.
+      for (auto elt : D->getAllElements()) {
+        if (!elt->hasAssociatedValues())
+          continue;
+        auto eltInterfaceTy = elt->getInterfaceType()->getCanonicalType();
+        auto origEltType = AbstractionPattern(
+            D->getGenericSignature().getCanonicalSignature(), eltInterfaceTy);
+        auto eltProperties =
+            classifyType(origEltType, eltInterfaceTy, TC, Expansion);
+        properties = mergeHasPack(eltProperties.isOrContainsPack(), properties);
+      }
+
       // If the whole enum is indirect, we lower it as if all payload
       // cases were indirect. This means a fixed-layout indirect enum
       // is always loadable and nontrivial. A resilient indirect enum
@@ -4646,6 +4684,7 @@ void TypeLowering::print(llvm::raw_ostream &os) const {
      << "isOrContainsRawPointer: " << BOOL(Properties.isOrContainsRawPointer())
      << ".\n"
      << "isLexical: " << BOOL(Properties.isLexical()) << ".\n"
+     << "isOrContainsPack: " << BOOL(Properties.isOrContainsPack()) << ".\n"
      << "\n";
 }
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -6270,7 +6270,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   }
 
   void checkAllocPackMetadataInst(AllocPackMetadataInst *apmi) {
-    require(apmi->getIntroducer()->mayRequirePackMetadata(),
+    require(apmi->getIntroducer()->mayRequirePackMetadata(*apmi->getFunction()),
             "Introduces instruction of kind which cannot emit on-stack pack "
             "metadata");
     require(F.getModule().getStage() == SILStage::Lowered,