Merge pull request #22803 from slavapestov/sil-type-lowering-resilience

slavapestov · web-flow · commit 498610512055 · 2019-02-22T11:17:24.000-05:00
SIL: Plumb ResilienceExpansion through TypeLowering more carefully
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -2148,12 +2148,18 @@ class SILBuilder {
   }
 
   bool isLoadableOrOpaque(SILType Ty) {
-    if (!F) {
-      // We are inserting into the static initializer of a SILGlobalVariable.
-      // All types used there are loadable by definition.
+    auto &M = C.Module;
+
+    if (!SILModuleConventions(M).useLoweredAddresses())
       return true;
-    }
-    return Ty.isLoadableOrOpaque(F);
+
+    auto expansion = ResilienceExpansion::Maximal;
+    // If there's no current SILFunction, we're inserting into a global
+    // variable initializer.
+    if (F)
+      expansion = F->getResilienceExpansion();
+
+    return M.getTypeLowering(Ty, expansion).isLoadable();
   }
 
   void appendOperandTypeName(SILType OpdTy, llvm::SmallString<16> &Name) {
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
@@ -306,23 +306,6 @@ class TypeLowering {
     return Properties.isResilient();
   }
 
-  /// Return the semantic type.
-  ///
-  /// The semantic type is what a type pretends to be during
-  /// type-checking: that is, the type that getTypeOfRValue would
-  /// return on a variable of this type.
-  SILType getSemanticType() const {
-    // If you change this, change getSemanticTypeLowering() too.
-    auto storageType = getLoweredType().getASTType();
-    if (auto refType = dyn_cast<ReferenceStorageType>(storageType))
-      return SILType::getPrimitiveType(refType.getReferentType(),
-                                       SILValueCategory::Object);
-    return getLoweredType();
-  }
-  
-  /// Return the lowering for the semantic type.
-  inline const TypeLowering &getSemanticTypeLowering(TypeConverter &TC) const;
-
   /// Produce an exact copy of the value in the given address as a
   /// scalar.  The caller is responsible for destroying this value,
   /// e.g. by releasing it.
@@ -582,13 +565,6 @@ class TypeConverter {
 
   llvm::BumpPtrAllocator IndependentBPA;
 
-  enum : unsigned {
-    /// There is a unique entry with this uncurry level in the
-    /// type-lowering map for every TLI we create.  The map has the
-    /// responsibility to call the destructor for these entries.
-    UniqueLoweringEntry = ~0U
-  };
-
   struct CachingTypeKey {
     GenericSignature *Sig;
     AbstractionPattern::CachingKey OrigType;
@@ -700,8 +676,16 @@ class TypeConverter {
 #include "swift/SIL/BridgedTypes.def"
 
   const TypeLowering &
-  getTypeLoweringForLoweredType(TypeKey key, ResilienceExpansion forExpansion);
-  const TypeLowering &getTypeLoweringForUncachedLoweredType(TypeKey key);
+  getTypeLoweringForLoweredType(TypeKey key,
+                                ResilienceExpansion forExpansion);
+  const TypeLowering &
+  getTypeLoweringForUncachedLoweredType(TypeKey key,
+                                        ResilienceExpansion forExpansion);
+
+  const TypeLowering &
+  getTypeLoweringForExpansion(TypeKey key,
+                              ResilienceExpansion forExpansion,
+                              const TypeLowering *lowering);
 
 public:
   SILModule &M;
@@ -763,15 +747,19 @@ class TypeConverter {
   
   /// Lowers a Swift type to a SILType, and returns the SIL TypeLowering
   /// for that type.
-  const TypeLowering &getTypeLowering(Type t) {
+  const TypeLowering &
+  getTypeLowering(Type t, ResilienceExpansion forExpansion =
+                            ResilienceExpansion::Minimal) {
     AbstractionPattern pattern(getCurGenericContext(), t->getCanonicalType());
-    return getTypeLowering(pattern, t);
+    return getTypeLowering(pattern, t, forExpansion);
   }
 
   /// Lowers a Swift type to a SILType according to the abstraction
   /// patterns of the given original type.
   const TypeLowering &getTypeLowering(AbstractionPattern origType,
-                                      Type substType);
+                                      Type substType,
+                                      ResilienceExpansion forExpansion =
+                                        ResilienceExpansion::Minimal);
 
   /// Returns the SIL TypeLowering for an already lowered SILType. If the
   /// SILType is an address, returns the TypeLowering for the pointed-to
@@ -782,16 +770,19 @@ class TypeConverter {
 
   // Returns the lowered SIL type for a Swift type.
   SILType getLoweredType(Type t) {
-    return getTypeLowering(t).getLoweredType();
+    return getTypeLowering(t, ResilienceExpansion::Minimal).getLoweredType();
   }
 
   // Returns the lowered SIL type for a Swift type.
   SILType getLoweredType(AbstractionPattern origType, Type substType) {
-    return getTypeLowering(origType, substType).getLoweredType();
+    return getTypeLowering(origType, substType, ResilienceExpansion::Minimal)
+      .getLoweredType();
   }
 
-  SILType getLoweredLoadableType(Type t) {
-    const TypeLowering &ti = getTypeLowering(t);
+  SILType getLoweredLoadableType(Type t,
+                                 ResilienceExpansion forExpansion =
+                                   ResilienceExpansion::Minimal) {
+    const TypeLowering &ti = getTypeLowering(t, forExpansion);
     assert(
         (ti.isLoadable() || !SILModuleConventions(M).useLoweredAddresses()) &&
         "unexpected address-only type");
@@ -1033,15 +1024,6 @@ class TypeConverter {
                                bool suppressOptional);
 };
 
-inline const TypeLowering &
-TypeLowering::getSemanticTypeLowering(TypeConverter &TC) const {
-  // If you change this, change getSemanticType() too.
-  auto storageType = getLoweredType().getASTType();
-  if (auto refType = dyn_cast<ReferenceStorageType>(storageType))
-    return TC.getTypeLowering(refType.getReferentType());
-  return *this;
-}
-
 /// RAII interface to push a generic context.
 class GenericContextScope {
   TypeConverter &TC;
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
@@ -97,6 +97,7 @@ CaptureKind TypeConverter::getDeclCaptureKind(CapturedValue capture) {
     // by its address (like a var) instead.
     if (var->isImmutable() &&
         (!SILModuleConventions(M).useLoweredAddresses() ||
+         // FIXME: Expansion
          !getTypeLowering(var->getType()).isAddressOnly()))
       return CaptureKind::Constant;
 
@@ -323,7 +324,7 @@ namespace {
       auto concreteType = getConcreteReferenceStorageReferent(referentType); \
       auto &ctx = M.getASTContext(); \
       if (Name##StorageType::get(concreteType, ctx) \
-            ->isLoadable(ResilienceExpansion::Maximal)) {         \
+            ->isLoadable(Expansion)) { \
         return asImpl().visitLoadable##Name##StorageType(type); \
       } else { \
         return asImpl().visitAddressOnly##Name##StorageType(type); \
@@ -458,14 +459,14 @@ namespace {
 
       // Consult the type lowering.
       type = getSubstitutedTypeForTypeLowering(type);
-      auto &lowering = M.Types.getTypeLowering(type);
+      auto &lowering = M.Types.getTypeLowering(type, Expansion);
       return handleClassificationFromLowering(type, lowering);
     }
 
     RecursiveProperties visitAnyStructType(CanType type, StructDecl *D) {
       // Consult the type lowering.
       type = getSubstitutedTypeForTypeLowering(type);
-      auto &lowering = M.Types.getTypeLowering(type);
+      auto &lowering = M.Types.getTypeLowering(type, Expansion);
       return handleClassificationFromLowering(type, lowering);
     }
 
@@ -850,6 +851,7 @@ namespace {
       unsigned index = 0;
       for (auto elt : tupleTy.getElementTypes()) {
         auto silElt = SILType::getPrimitiveType(elt, silTy.getCategory());
+        // FIXME: Expansion
         children.push_back(Child{index, M.Types.getTypeLowering(silElt)});
         ++index;
       }
@@ -884,6 +886,7 @@ namespace {
       
       for (auto prop : structDecl->getStoredProperties()) {
         SILType propTy = silTy.getFieldType(prop, M);        
+        // FIXME: Expansion
         children.push_back(Child{prop, M.Types.getTypeLowering(propTy)});
       }
     }
@@ -1161,7 +1164,7 @@ namespace {
     }
 
     TypeLowering *handleAddressOnly(CanType type,
-                                          RecursiveProperties properties) {
+                                    RecursiveProperties properties) {
       if (SILModuleConventions(M).useLoweredAddresses()) {
         auto silType = SILType::getPrimitiveAddressType(type);
         return new (TC, Dependent) AddressOnlyTypeLowering(silType, properties);
@@ -1187,7 +1190,7 @@ namespace {
     TypeLowering *visitTupleType(CanTupleType tupleType) {
       RecursiveProperties properties;
       for (auto eltType : tupleType.getElementTypes()) {
-        auto &lowering = TC.getTypeLowering(eltType);
+        auto &lowering = TC.getTypeLowering(eltType, Expansion);
         properties.addSubobject(lowering.getRecursiveProperties());
       }
 
@@ -1258,7 +1261,7 @@ namespace {
 
     template <class LoadableLoweringClass>
     TypeLowering *handleAggregateByProperties(CanType type,
-                                                    RecursiveProperties props) {
+                                              RecursiveProperties props) {
       if (props.isAddressOnly()) {
         return handleAddressOnly(type, props);
       }
@@ -1422,7 +1425,8 @@ TypeConverter::getSILFunctionType(AbstractionPattern origType,
 
 const TypeLowering &
 TypeConverter::getTypeLowering(AbstractionPattern origType,
-                               Type origSubstType) {
+                               Type origSubstType,
+                               ResilienceExpansion forExpansion) {
   CanType substType = origSubstType->getCanonicalType();
   auto key = getTypeKey(origType, substType);
   
@@ -1431,7 +1435,7 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
   assert(!substType->is<InOutType>());
 
   if (auto existing = find(key))
-    return *existing;
+    return getTypeLoweringForExpansion(key, forExpansion, existing);
 
   // Lower the type.
   CanType loweredSubstType =
@@ -1441,7 +1445,7 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
   // point in re-checking the table, so just construct a type lowering
   // and cache it.
   if (loweredSubstType == substType && key.isCacheable()) {
-    return getTypeLoweringForUncachedLoweredType(key);
+    return getTypeLoweringForUncachedLoweredType(key, forExpansion);
   }
 
   // Otherwise, check the table at a key that would be used by the
@@ -1452,7 +1456,7 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
   auto loweredKey = getTypeKey(origTypeForCaching, loweredSubstType);
 
   auto &lowering = getTypeLoweringForLoweredType(loweredKey,
-                                                 ResilienceExpansion::Minimal);
+                                                 forExpansion);
   insert(key, &lowering);
   return lowering;
 }
@@ -1582,17 +1586,22 @@ TypeConverter::getTypeLoweringForLoweredType(TypeKey key,
   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.
   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");
+  if (!lowering)
+    lowering = &getTypeLoweringForUncachedLoweredType(key, forExpansion);
+
+  return getTypeLoweringForExpansion(key, forExpansion, lowering);
+}
 
-  if (key.isDependent() || !lowering->isResilient()) {
+/// When we've found a type lowering for one resilience expansion,
+/// check if its the one we want; if not, walk the list until we
+/// find the right one, or create a new lowering and add it to
+/// the end of the list.
+const TypeLowering & TypeConverter::
+getTypeLoweringForExpansion(TypeKey key,
+                            ResilienceExpansion forExpansion,
+                            const TypeLowering *lowering) {
+  if (!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;
@@ -1622,8 +1631,9 @@ TypeConverter::getTypeLoweringForLoweredType(TypeKey key,
 
 /// Do type-lowering for a lowered type which is not already in the cache,
 /// then insert it into the cache.
-const TypeLowering &
-TypeConverter::getTypeLoweringForUncachedLoweredType(TypeKey key) {
+const TypeLowering & TypeConverter::
+getTypeLoweringForUncachedLoweredType(TypeKey key,
+                                      ResilienceExpansion forExpansion) {
   assert(!find(key) && "re-entrant or already cached");
   assert(key.SubstType->isLegalSILType() && "type is not already lowered");
 
@@ -1632,12 +1642,13 @@ TypeConverter::getTypeLoweringForUncachedLoweredType(TypeKey key) {
   insert(key, nullptr);
 #endif
 
-  // FIXME: Get expansion from SILFunction
   auto *theInfo = LowerType(*this,
                             CanGenericSignature(),
-                            ResilienceExpansion::Minimal,
+                            forExpansion,
                             key.isDependent()).visit(key.SubstType);
 
+  theInfo->forExpansion = forExpansion;
+
   if (key.OrigType.isForeign()) {
     assert(theInfo->isLoadable() && "Cannot lower address-only type with "
            "foreign abstraction pattern");
@@ -2492,6 +2503,7 @@ CanSILBoxType TypeConverter::getBoxTypeForEnumElement(SILType enumType,
 static void countNumberOfInnerFields(unsigned &fieldsCount, SILModule &Module,
                                      SILType Ty) {
   if (auto *structDecl = Ty.getStructOrBoundGenericStruct()) {
+    // FIXME: Expansion
     assert(!structDecl->isResilient(Module.getSwiftModule(),
                                     ResilienceExpansion::Minimal) &&
            " FSO should not be trying to explode resilient (ie address-only) "
@@ -2519,6 +2531,7 @@ static void countNumberOfInnerFields(unsigned &fieldsCount, SILModule &Module,
     if (enumDecl->isIndirect()) {
       return;
     }
+    // FIXME: Expansion
     assert(!enumDecl->isResilient(Module.getSwiftModule(),
                                   ResilienceExpansion::Minimal) &&
            " FSO should not be trying to explode resilient (ie address-only) "
diff --git a/test/SILOptimizer/globalopt_resilience.swift b/test/SILOptimizer/globalopt_resilience.swift
@@ -32,3 +32,23 @@ public func cannotConvertToValueUse() {
 // CHECK: apply [[METHOD]]([[ADDR]]) : $@convention(method) (@in_guaranteed ResilientStruct) -> ()
 // CHECK: [[RESULT:%.*]] = tuple ()
 // CHECK: return [[RESULT]] : $()
+
+internal struct WrapperStruct {
+  var inner: ResilientStruct = .staticVal
+
+  init() {}
+}
+
+func returnWrapperStruct() -> WrapperStruct {
+  return WrapperStruct()
+}
+
+// CHECK-LABEL: sil hidden @$s4test19returnWrapperStructAA0cD0VyF : $@convention(thin) () -> @out WrapperStruct
+// CHECK: bb0(%0 : $*WrapperStruct):
+// CHECK: [[INT:%.*]] = integer_literal $Builtin.Int{{32|64}}, 27
+// CHECK: [[S1:%.*]] = struct $Int ([[INT]] : $Builtin.Int{{32|64}})
+// CHECK: [[S2:%.*]] = struct $ResilientStruct ([[S1]] : $Int)
+// CHECK: [[S3:%.*]] = struct $WrapperStruct ([[S2]] : $ResilientStruct)
+// CHECK: store [[S3]] to %0 : $*WrapperStruct
+// CHECK: [[RESULT:%.*]] = tuple ()
+// CHECK: return [[RESULT]] : $()
