SIL: Store type lowerings for multiple resilience expansions

eeckstein · eeckstein · commit 41e2e29f8387 · 2019-01-04T11:21:25.000-08:00
This lets the SIL optimizer reason about types (e.g. if a type is loadable) in specific functions.
For example, a type might be loadable in a resilient function, but not in an inlinable function.
diff --git a/include/swift/SIL/SILModule.h b/include/swift/SIL/SILModule.h
@@ -316,8 +316,10 @@ class SILModule {
   mutable Lowering::TypeConverter Types;
 
   /// Look up the TypeLowering for a SILType.
-  const Lowering::TypeLowering &getTypeLowering(SILType t) {
-    return Types.getTypeLowering(t);
+  const Lowering::TypeLowering &
+  getTypeLowering(SILType t, ResilienceExpansion expansion =
+                               ResilienceExpansion::Minimal) {
+    return Types.getTypeLowering(t, expansion);
   }
 
   /// Invalidate cached entries in SIL Loader.
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -257,14 +257,35 @@ class SILType {
   bool isLoadable(SILModule &M) const {
     return !isAddressOnly(M);
   }
+
+  /// Like isLoadable(SILModule), but specific to a function.
+  ///
+  /// This takes the resilience expansion of the function into account. If the
+  /// type is not loadable in general (because it's resilient), it still might
+  /// be loadable inside a resilient function in the module.
+  /// In other words: isLoadable(SILModule) is the conservative default, whereas
+  /// isLoadable(SILFunction) might give a more optimistic result.
+  bool isLoadable(SILFunction *inFunction) const {
+    return !isAddressOnly(inFunction);
+  }
+
   /// True if either:
   /// 1) The type, or the referenced type of an address type, is loadable.
   /// 2) The SIL Module conventions uses lowered addresses
   bool isLoadableOrOpaque(SILModule &M) const;
+
+  /// Like isLoadableOrOpaque(SILModule), but takes the resilience expansion of
+  /// \p inFunction into account (see isLoadable(SILFunction)).
+  bool isLoadableOrOpaque(SILFunction *inFunction) const;
+
   /// True if the type, or the referenced type of an address type, is
   /// address-only. This is the opposite of isLoadable.
   bool isAddressOnly(SILModule &M) const;
 
+  /// Like isAddressOnly(SILModule), but takes the resilience expansion of
+  /// \p inFunction into account (see isLoadable(SILFunction)).
+  bool isAddressOnly(SILFunction *inFunction) const;
+
   /// True if the type, or the referenced type of an address type, is trivial.
   bool isTrivial(SILModule &M) const;
 
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
@@ -148,6 +148,12 @@ enum IsReferenceCounted_t : bool {
   IsReferenceCounted = true
 };
 
+/// Is this type address only because it's resilient?
+enum IsResilient_t : bool {
+  IsNotResilient = false,
+  IsResilient = true
+};
+
 /// Extended type information used by SIL.
 class TypeLowering {
 public:
@@ -157,6 +163,7 @@ class TypeLowering {
       NonTrivialFlag     = 1 << 0,
       NonFixedABIFlag    = 1 << 1,
       AddressOnlyFlag    = 1 << 2,
+      ResilientFlag      = 1 << 3,
     };
 
     uint8_t Flags;
@@ -167,17 +174,23 @@ class TypeLowering {
 
     constexpr RecursiveProperties(IsTrivial_t isTrivial,
                                   IsFixedABI_t isFixedABI,
-                                  IsAddressOnly_t isAddressOnly)
+                                  IsAddressOnly_t isAddressOnly,
+                                  IsResilient_t isResilient = IsNotResilient)
       : Flags((isTrivial ? 0U : NonTrivialFlag) | 
               (isAddressOnly ? AddressOnlyFlag : 0U) |
-              (isFixedABI ? 0U : NonFixedABIFlag)) {}
+              (isFixedABI ? 0U : NonFixedABIFlag) |
+              (isResilient ? ResilientFlag : 0U)) {}
 
     static constexpr RecursiveProperties forReference() {
-      return {IsNotTrivial, IsFixedABI, IsNotAddressOnly};
+      return {IsNotTrivial, IsFixedABI, IsNotAddressOnly, IsNotResilient };
     }
 
     static constexpr RecursiveProperties forOpaque() {
-      return {IsNotTrivial, IsNotFixedABI, IsAddressOnly};
+      return {IsNotTrivial, IsNotFixedABI, IsAddressOnly, IsNotResilient};
+    }
+
+    static constexpr RecursiveProperties forResilient() {
+      return {IsNotTrivial, IsNotFixedABI, IsAddressOnly, IsResilient};
     }
 
     void addSubobject(RecursiveProperties other) {
@@ -193,6 +206,9 @@ class TypeLowering {
     IsAddressOnly_t isAddressOnly() const {
       return IsAddressOnly_t((Flags & AddressOnlyFlag) != 0);
     }
+    IsResilient_t isResilient() const {
+      return IsResilient_t((Flags & ResilientFlag) != 0);
+    }
 
     void setNonTrivial() { Flags |= NonTrivialFlag; }
     void setNonFixedABI() { Flags |= NonFixedABIFlag; }
@@ -206,7 +222,16 @@ class TypeLowering {
   RecursiveProperties Properties;
   unsigned ReferenceCounted : 1;
 
-protected:  
+public:
+  /// The resilience expansion for this type lowering.
+  /// If the type is not resilient at all, this is always Minimal.
+  ResilienceExpansion forExpansion = ResilienceExpansion::Minimal;
+
+  /// A single linked list of lowerings for different resilience expansions.
+  /// The first lowering is always for ResilientExpansion::Minimal.
+  mutable const TypeLowering *nextExpansion = nullptr;
+
+protected:
   TypeLowering(SILType type, RecursiveProperties properties,
                IsReferenceCounted_t isRefCounted)
     : LoweredType(type), Properties(properties),
@@ -277,6 +302,10 @@ class TypeLowering {
     return LoweredType.isAddress();
   }
 
+  bool isResilient() const {
+    return Properties.isResilient();
+  }
+
   /// Return the semantic type.
   ///
   /// The semantic type is what a type pretends to be during
@@ -670,7 +699,8 @@ class TypeConverter {
   Optional<CanType> BridgedType##Ty;
 #include "swift/SIL/BridgedTypes.def"
 
-  const TypeLowering &getTypeLoweringForLoweredType(TypeKey key);
+  const TypeLowering &
+  getTypeLoweringForLoweredType(TypeKey key, ResilienceExpansion forExpansion);
   const TypeLowering &getTypeLoweringForUncachedLoweredType(TypeKey key);
 
 public:
@@ -746,7 +776,9 @@ class TypeConverter {
   /// Returns the SIL TypeLowering for an already lowered SILType. If the
   /// SILType is an address, returns the TypeLowering for the pointed-to
   /// type.
-  const TypeLowering &getTypeLowering(SILType t);
+  const TypeLowering &
+  getTypeLowering(SILType t, ResilienceExpansion forExpansion =
+                               ResilienceExpansion::Minimal);
 
   // Returns the lowered SIL type for a Swift type.
   SILType getLoweredType(Type t) {
diff --git a/lib/SIL/SILType.cpp b/lib/SIL/SILType.cpp
@@ -175,13 +175,24 @@ bool SILType::isLoadableOrOpaque(SILModule &M) const {
   return isLoadable(M) || !SILModuleConventions(M).useLoweredAddresses();
 }
 
+bool SILType::isLoadableOrOpaque(SILFunction *inFunction) const {
+  SILModule &M = inFunction->getModule();
+  return isLoadable(inFunction) ||
+         !SILModuleConventions(M).useLoweredAddresses();
+}
+
 /// True if the type, or the referenced type of an address type, is
 /// address-only. For example, it could be a resilient struct or something of
 /// unknown size.
 bool SILType::isAddressOnly(SILModule &M) const {
   return M.getTypeLowering(*this).isAddressOnly();
 }
 
+bool SILType::isAddressOnly(SILFunction *inFunction) const {
+  return inFunction->getModule().getTypeLowering(*this,
+                        inFunction->getResilienceExpansion()).isAddressOnly();
+}
+
 SILType SILType::substGenericArgs(SILModule &M,
                                   SubstitutionMap SubMap) const {
   auto fnTy = castTo<SILFunctionType>();
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
@@ -1139,7 +1139,7 @@ namespace {
   /// Build the appropriate TypeLowering subclass for the given type,
   /// which is assumed to already have been lowered.
   class LowerType
-    : public TypeClassifierBase<LowerType, const TypeLowering *>
+    : public TypeClassifierBase<LowerType, TypeLowering *>
   {
     TypeConverter &TC;
     IsDependent_t Dependent;
@@ -1149,18 +1149,18 @@ namespace {
       : TypeClassifierBase(TC.M, Sig, Expansion),
         TC(TC), Dependent(Dependent) {}
 
-    const TypeLowering *
+    TypeLowering *
     handleTrivial(CanType type) {
       auto silType = SILType::getPrimitiveObjectType(type);
       return new (TC, Dependent) TrivialTypeLowering(silType);
     }
 
-    const TypeLowering *handleReference(CanType type) {
+    TypeLowering *handleReference(CanType type) {
       auto silType = SILType::getPrimitiveObjectType(type);
       return new (TC, Dependent) ReferenceTypeLowering(silType);
     }
 
-    const TypeLowering *handleAddressOnly(CanType type, 
+    TypeLowering *handleAddressOnly(CanType type,
                                           RecursiveProperties properties) {
       if (SILModuleConventions(M).useLoweredAddresses()) {
         auto silType = SILType::getPrimitiveAddressType(type);
@@ -1171,20 +1171,20 @@ namespace {
     }
 
 #define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
-    const TypeLowering * \
+    TypeLowering * \
     visitLoadable##Name##StorageType(Can##Name##StorageType type) { \
       return new (TC, Dependent) Loadable##Name##TypeLowering( \
                                   SILType::getPrimitiveObjectType(type)); \
     }
 #include "swift/AST/ReferenceStorage.def"
 
-    const TypeLowering *
+    TypeLowering *
     visitBuiltinUnsafeValueBufferType(CanBuiltinUnsafeValueBufferType type) {
       auto silType = SILType::getPrimitiveAddressType(type);
       return new (TC, Dependent) UnsafeValueBufferTypeLowering(silType);
     }
 
-    const TypeLowering *visitTupleType(CanTupleType tupleType) {
+    TypeLowering *visitTupleType(CanTupleType tupleType) {
       RecursiveProperties properties;
       for (auto eltType : tupleType.getElementTypes()) {
         auto &lowering = TC.getTypeLowering(eltType);
@@ -1195,13 +1195,13 @@ namespace {
                                                                     properties);
     }
 
-    const TypeLowering *visitAnyStructType(CanType structType, StructDecl *D) {
+    TypeLowering *visitAnyStructType(CanType structType, StructDecl *D) {
 
       // For now, if the type does not have a fixed layout in all resilience
       // domains, we will treat it as address-only in SIL.
       if (D->isResilient(M.getSwiftModule(), Expansion))
         return handleAddressOnly(structType,
-                                 RecursiveProperties::forOpaque());
+                                 RecursiveProperties::forResilient());
 
       // Classify the type according to its stored properties.
       RecursiveProperties properties;
@@ -1216,11 +1216,11 @@ namespace {
                                                                     properties);
     }
         
-    const TypeLowering *visitAnyEnumType(CanType enumType, EnumDecl *D) {
+    TypeLowering *visitAnyEnumType(CanType enumType, EnumDecl *D) {
       // For now, if the type does not have a fixed layout in all resilience
       // domains, we will treat it as address-only in SIL.
       if (D->isResilient(M.getSwiftModule(), Expansion))
-        return handleAddressOnly(enumType, RecursiveProperties::forOpaque());
+        return handleAddressOnly(enumType, RecursiveProperties::forResilient());
 
       // If the whole enum is indirect, we lower it as if all payload
       // cases were indirect. This means a fixed-layout indirect enum
@@ -1257,7 +1257,7 @@ namespace {
     }
 
     template <class LoadableLoweringClass>
-    const TypeLowering *handleAggregateByProperties(CanType type,
+    TypeLowering *handleAggregateByProperties(CanType type,
                                                     RecursiveProperties props) {
       if (props.isAddressOnly()) {
         return handleAddressOnly(type, props);
@@ -1451,7 +1451,8 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
     AbstractionPattern(getCurGenericContext(), loweredSubstType);
   auto loweredKey = getTypeKey(origTypeForCaching, loweredSubstType);
 
-  auto &lowering = getTypeLoweringForLoweredType(loweredKey);
+  auto &lowering = getTypeLoweringForLoweredType(loweredKey,
+                                                 ResilienceExpansion::Minimal);
   insert(key, &lowering);
   return lowering;
 }
@@ -1565,27 +1566,58 @@ CanType TypeConverter::getLoweredRValueType(AbstractionPattern origType,
   return substType;
 }
 
-const TypeLowering &TypeConverter::getTypeLowering(SILType type) {
+const TypeLowering &
+TypeConverter::getTypeLowering(SILType type, ResilienceExpansion forExpansion) {
   auto loweredType = type.getASTType();
   auto key = getTypeKey(AbstractionPattern(getCurGenericContext(), loweredType),
                         loweredType);
 
-  return getTypeLoweringForLoweredType(key);
+  return getTypeLoweringForLoweredType(key, forExpansion);
 }
 
 const TypeLowering &
-TypeConverter::getTypeLoweringForLoweredType(TypeKey key) {
+TypeConverter::getTypeLoweringForLoweredType(TypeKey key,
+                                             ResilienceExpansion forExpansion) {
   auto type = key.SubstType;
   assert(type->isLegalSILType() && "type is not lowered!");
   (void)type;
 
   // Re-using uncurry level 0 is reasonable because our uncurrying
   // transforms are idempotent at this level.  This means we don't
   // need a ton of redundant entries in the map.
-  if (auto existing = find(key))
-    return *existing;
+  const TypeLowering *lowering = find(key);
+  if (!lowering) {
+    lowering = &getTypeLoweringForUncachedLoweredType(key);
+  }
+  assert(lowering->forExpansion == ResilienceExpansion::Minimal &&
+         "the first lowering in the list must be for minimal expansion");
 
-  return getTypeLoweringForUncachedLoweredType(key);
+  if (key.isDependent() || !lowering->isResilient()) {
+    // Don't try to refine the lowering for other resilience expansions if
+    // we don't expect to get a different lowering anyway.
+    return *lowering;
+  }
+
+  // Search for a matching lowering in the linked list of lowerings.
+  while (true) {
+    if (lowering->forExpansion == forExpansion)
+      return *lowering;
+    if (lowering->nextExpansion) {
+      // Continue searching.
+      lowering = lowering->nextExpansion;
+      continue;
+    }
+
+    // Create a new lowering for the resilience expansion.
+    TypeLowering *theInfo = LowerType(*this,
+                              CanGenericSignature(),
+                              forExpansion,
+                              key.isDependent()).visit(key.SubstType);
+
+    lowering->nextExpansion = theInfo;
+    theInfo->forExpansion = forExpansion;
+    return *theInfo;
+  }
 }
 
 /// Do type-lowering for a lowered type which is not already in the cache,
