SIL: Lower fields that are conditionally addressable because of a dependency.

include/swift/AST/LifetimeDependence.h

@@ -45,18 +45,25 @@ enum class ParsedLifetimeDependenceKind : uint8_t {
 enum class LifetimeDependenceKind : uint8_t { Inherit = 0, Scope };
 
 struct LifetimeDescriptor {
+  enum IsAddressable_t {
+    IsNotAddressable,
+    IsConditionallyAddressable,
+    IsAddressable,
+  };
+
   union Value {
     struct {
       Identifier name;
     } Named;
     struct {
       unsigned index;
-      bool isAddress;
+      IsAddressable_t isAddress;
     } Ordered;
     struct {
     } Self;
     Value(Identifier name) : Named({name}) {}
-    Value(unsigned index, bool isAddress) : Ordered({index, isAddress}) {}
+    Value(unsigned index, IsAddressable_t isAddress)
+      : Ordered({index, isAddress}) {}
     Value() : Self() {}
   } value;
 
@@ -72,7 +79,7 @@ struct LifetimeDescriptor {
                      SourceLoc loc)
       : value{name}, kind(DescriptorKind::Named),
         parsedLifetimeDependenceKind(parsedLifetimeDependenceKind), loc(loc) {}
-  LifetimeDescriptor(unsigned index, bool isAddress,
+  LifetimeDescriptor(unsigned index, IsAddressable_t isAddress,
                      ParsedLifetimeDependenceKind parsedLifetimeDependenceKind,
                      SourceLoc loc)
       : value{index, isAddress}, kind(DescriptorKind::Ordered),
@@ -93,7 +100,7 @@ struct LifetimeDescriptor {
   forOrdered(unsigned index,
              ParsedLifetimeDependenceKind parsedLifetimeDependenceKind,
              SourceLoc loc,
-             bool isAddress = false) {
+             IsAddressable_t isAddress = IsNotAddressable) {
     return {index, isAddress, parsedLifetimeDependenceKind, loc};
   }
   static LifetimeDescriptor
@@ -116,10 +123,10 @@ struct LifetimeDescriptor {
     return value.Ordered.index;
   }
 
-  bool isAddressable() const {
+  IsAddressable_t isAddressable() const {
     return kind == DescriptorKind::Ordered
       ? value.Ordered.isAddress
-      : false;
+      : IsNotAddressable;
   }
 
   DescriptorKind getDescriptorKind() const { return kind; }
@@ -216,6 +223,8 @@ class LifetimeDependenceInfo {
   IndexSubset *scopeLifetimeParamIndices;
   llvm::PointerIntPair<IndexSubset *, 1, bool>
     addressableParamIndicesAndImmortal;
+  IndexSubset *conditionallyAddressableParamIndices;
+
   unsigned targetIndex;
 
   static LifetimeDependenceInfo getForIndex(AbstractFunctionDecl *afd,
@@ -249,16 +258,23 @@ class LifetimeDependenceInfo {
                          IndexSubset *scopeLifetimeParamIndices,
                          unsigned targetIndex, bool isImmortal,
                          // set during SIL type lowering
-                         IndexSubset *addressableParamIndices = nullptr)
+                         IndexSubset *addressableParamIndices = nullptr,
+                         IndexSubset *conditionallyAddressableParamIndices = nullptr)
       : inheritLifetimeParamIndices(inheritLifetimeParamIndices),
         scopeLifetimeParamIndices(scopeLifetimeParamIndices),
         addressableParamIndicesAndImmortal(addressableParamIndices, isImmortal),
+        conditionallyAddressableParamIndices(conditionallyAddressableParamIndices),
         targetIndex(targetIndex) {
     assert(this->isImmortal() || inheritLifetimeParamIndices ||
            scopeLifetimeParamIndices);
     assert(!inheritLifetimeParamIndices ||
            !inheritLifetimeParamIndices->isEmpty());
     assert(!scopeLifetimeParamIndices || !scopeLifetimeParamIndices->isEmpty());
+    assert((!conditionallyAddressableParamIndices
+            || (addressableParamIndices
+                && conditionallyAddressableParamIndices
+                    ->isSubsetOf(addressableParamIndices)))
+     && "conditionally-addressable params not a subset of addressable params?");
   }
 
   operator bool() const { return !empty(); }
@@ -286,9 +302,26 @@ class LifetimeDependenceInfo {
 
   IndexSubset *getScopeIndices() const { return scopeLifetimeParamIndices; }
 
+  /// Return the set of parameters which have addressable dependencies.
+  ///
+  /// This indicates that any dependency on the parameter value is dependent
+  /// not only on the value, but the memory location of a particular instance
+  /// of the value.
   IndexSubset *getAddressableIndices() const {
     return addressableParamIndicesAndImmortal.getPointer();
   }
+  /// Return the set of parameters which may have addressable dependencies
+  /// depending on the type of the parameter.
+  ///
+  /// Generic parameters need to be conservatively treated as addressable in
+  /// situations where the substituted type may end up being addressable-for-
+  /// dependencies. If substitution at a call site or specialization results
+  /// in the type becoming concretely non-addressable-for-dependencies,
+  /// then the lifetime dependency can be considered a normal value
+  /// dependency.
+  IndexSubset *getConditionallyAddressableIndices() const {
+    return conditionallyAddressableParamIndices;
+  }
 
   bool checkInherit(int index) const {
     return inheritLifetimeParamIndices

lib/AST/LifetimeDependence.cpp

@@ -50,6 +50,7 @@ getLifetimeDependenceFor(ArrayRef<LifetimeDependenceInfo> lifetimeDependencies,
 std::string LifetimeDependenceInfo::getString() const {
   std::string lifetimeDependenceString = "@lifetime(";
   auto addressable = getAddressableIndices();
+  auto condAddressable = getConditionallyAddressableIndices();
 
   auto getSourceString = [&](IndexSubset *bitvector, StringRef kind) {
     std::string result;
@@ -61,7 +62,11 @@ std::string LifetimeDependenceInfo::getString() const {
         }
         result += kind;
         if (addressable && addressable->contains(i)) {
-          result += "address ";
+          if (condAddressable && condAddressable->contains(i)) {
+            result += "address_for_deps ";
+          } else {
+            result += "address ";
+          }
         }
         result += std::to_string(i);
         isFirstSetBit = false;
@@ -452,6 +457,7 @@ std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::fromDependsOn(
   SmallBitVector inheritLifetimeParamIndices(capacity);
   SmallBitVector scopeLifetimeParamIndices(capacity);
   SmallBitVector addressableLifetimeParamIndices(capacity);
+  SmallBitVector conditionallyAddressableLifetimeParamIndices(capacity);
 
   auto updateLifetimeDependenceInfo = [&](LifetimeDescriptor descriptor,
                                           unsigned paramIndexToSet,
@@ -494,8 +500,16 @@ std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::fromDependsOn(
       if (updateLifetimeDependenceInfo(source, index, paramConvention)) {
         return std::nullopt;
       }
-      if (source.isAddressable()) {
+      switch (source.isAddressable()) {
+      case LifetimeDescriptor::IsNotAddressable:
+        break;
+      case LifetimeDescriptor::IsConditionallyAddressable:
+        conditionallyAddressableLifetimeParamIndices.set(index);
+        addressableLifetimeParamIndices.set(index);
+        break;
+      case LifetimeDescriptor::IsAddressable:
         addressableLifetimeParamIndices.set(index);
+        break;
       }
       break;
     }
@@ -523,6 +537,9 @@ std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::fromDependsOn(
       /*isImmortal*/ false,
       addressableLifetimeParamIndices.any()
           ? IndexSubset::get(ctx, addressableLifetimeParamIndices)
+          : nullptr,
+      conditionallyAddressableLifetimeParamIndices.any()
+          ? IndexSubset::get(ctx, conditionallyAddressableLifetimeParamIndices)
           : nullptr);
 }
 

lib/Parse/ParseDecl.cpp

@@ -2517,7 +2517,7 @@ parseLifetimeDescriptor(Parser &P,
     // In SIL, lifetimes explicitly state whether they are dependent on a
     // memory location in addition to the value stored at that location.
     if (P.isInSILMode()
-        && name.str() == "address"
+        && (name.str() == "address" || name.str() == "address_for_deps")
         && P.Tok.is(tok::integer_literal)) {
       SourceLoc orderedLoc;
       unsigned index;
@@ -2527,7 +2527,9 @@ parseLifetimeDescriptor(Parser &P,
         return std::nullopt;
       }
       return LifetimeDescriptor::forOrdered(index, lifetimeDependenceKind, loc,
-                                            /*addressable*/ true);
+        name.str() == "address_for_deps"
+          ? LifetimeDescriptor::IsConditionallyAddressable
+          : LifetimeDescriptor::IsAddressable);
     }
 
     return LifetimeDescriptor::forNamed(name, lifetimeDependenceKind, loc);

lib/SIL/IR/SILFunctionType.cpp

@@ -1578,6 +1578,7 @@ class DestructureInputs {
   SmallVectorImpl<SILParameterInfo> &Inputs;
   SmallVectorImpl<int> &ParameterMap;
   SmallBitVector &AddressableLoweredParameters;
+  SmallBitVector &ConditionallyAddressableLoweredParameters;
   unsigned NextOrigParamIndex = 0;
 
   void addLoweredParameter(SILParameterInfo parameter,
@@ -1593,11 +1594,13 @@ class DestructureInputs {
                     std::optional<ActorIsolation> isolationInfo,
                     SmallVectorImpl<SILParameterInfo> &inputs,
                     SmallVectorImpl<int> &parameterMap,
-                    SmallBitVector &addressableParams)
-      : expansion(expansion), TC(TC), Convs(conventions), Foreign(foreign),
-        IsolationInfo(isolationInfo), Inputs(inputs),
-        ParameterMap(parameterMap),
-        AddressableLoweredParameters(addressableParams)
+                    SmallBitVector &addressableParams,
+                    SmallBitVector &conditionallyAddressableParams)
+    : expansion(expansion), TC(TC), Convs(conventions), Foreign(foreign),
+      IsolationInfo(isolationInfo), Inputs(inputs),
+      ParameterMap(parameterMap),
+      AddressableLoweredParameters(addressableParams),
+      ConditionallyAddressableLoweredParameters(conditionallyAddressableParams)
   {}
 
   void destructure(AbstractionPattern origType,
@@ -1768,7 +1771,9 @@ class DestructureInputs {
 
     // Any parameters not yet marked addressable shouldn't be.
     assert(AddressableLoweredParameters.size() <= ParameterMap.size());
+    assert(ConditionallyAddressableLoweredParameters.size() <= ParameterMap.size());
     AddressableLoweredParameters.resize(ParameterMap.size(), false);
+    ConditionallyAddressableLoweredParameters.resize(ParameterMap.size(), false);
   }
 
   void visit(AbstractionPattern origType, AnyFunctionType::Param substParam,
@@ -1809,8 +1814,8 @@ class DestructureInputs {
     if (origFlags.isAddressable()) {
       origType = AbstractionPattern::getOpaque();
 
-      // Remember that this lowered parameter is addressable in the
-      // addressable parameters vector.
+      // Remember that this lowered parameter is unconditionally addressable in
+      // the addressable parameters vector.
       AddressableLoweredParameters.resize(ParameterMap.size() + 1, false);
       AddressableLoweredParameters[ParameterMap.size()] = true;
     } else if (hasScopedDependency) {
@@ -1821,10 +1826,14 @@ class DestructureInputs {
       if (initialSubstTL.getRecursiveProperties().isAddressableForDependencies()) {
         origType = AbstractionPattern::getOpaque();
 
-        // Remember that this lowered parameter is addressable in the
-        // addressable parameters vector.
+        // Remember that this lowered parameter is conditionally addressable in
+        // the addressable parameters vector.
         AddressableLoweredParameters.resize(ParameterMap.size() + 1, false);
         AddressableLoweredParameters[ParameterMap.size()] = true;
+
+        ConditionallyAddressableLoweredParameters
+          .resize(ParameterMap.size() + 1, false);
+        ConditionallyAddressableLoweredParameters[ParameterMap.size()] = true;
       }
     }
 
@@ -2565,6 +2574,7 @@ static CanSILFunctionType getSILFunctionType(
   SmallVector<SILParameterInfo, 8> inputs;
   SmallVector<int, 8> parameterMap;
   SmallBitVector addressableParams;
+  SmallBitVector conditionallyAddressableParams;
   {
     std::optional<ActorIsolation> actorIsolation;
     if (constant) {
@@ -2587,7 +2597,9 @@ static CanSILFunctionType getSILFunctionType(
     }
     DestructureInputs destructurer(expansionContext, TC, conventions,
                                    foreignInfo, actorIsolation, inputs,
-                                   parameterMap, addressableParams);
+                                   parameterMap,
+                                   addressableParams,
+                                   conditionallyAddressableParams);
     destructurer.destructure(origType, substFnInterfaceType.getParams(),
                              extInfoBuilder, unimplementable);
   }
@@ -2668,11 +2680,19 @@ static CanSILFunctionType getSILFunctionType(
       IndexSubset *addressableSet = addressableDeps.any()
         ? IndexSubset::get(TC.Context, addressableDeps)
         : nullptr;
+
+      SmallBitVector condAddressableDeps = scopeIndicesSet
+        ? scopeIndicesSet->getBitVector() & conditionallyAddressableParams
+        : SmallBitVector(1, false);
+      IndexSubset *condAddressableSet = condAddressableDeps.any()
+        ? IndexSubset::get(TC.Context, condAddressableDeps)
+        : nullptr;
 
       return LifetimeDependenceInfo(inheritIndicesSet,
                                     scopeIndicesSet,
                                     target, /*immortal*/ false,
-                                    addressableSet);
+                                    addressableSet,
+                                    condAddressableSet);
     };
   // Lower parameter dependencies.
   for (unsigned i = 0; i < parameterMap.size(); ++i) {
@@ -2759,10 +2779,12 @@ static CanSILFunctionType getSILFunctionTypeForInitAccessor(
     std::optional<ActorIsolation> actorIsolation; // For now always null.
     SmallVector<int, 8> unusedParameterMap;
     SmallBitVector unusedAddressableParams;
+    SmallBitVector unusedConditionalAddressableParams;
     DestructureInputs destructurer(context, TC, conventions, foreignInfo,
                                    actorIsolation, inputs,
                                    unusedParameterMap,
-                                   unusedAddressableParams);
+                                   unusedAddressableParams,
+                                   unusedConditionalAddressableParams);
     destructurer.destructure(
         origType, substAccessorType.getParams(),
         extInfoBuilder.withRepresentation(SILFunctionTypeRepresentation::Thin),

test/SIL/lifetime_dependence_generics.swift

@@ -34,7 +34,7 @@ public func test(pview: borrowing PView) -> View {
   return pview.getDefault()
 }
 
-// CHECK-LABEL: sil hidden @$s28lifetime_dependence_generics1PPAAE10getDefault1EQzyF : $@convention(method) <Self where Self : P> (@in_guaranteed Self) -> @lifetime(borrow address 0)  @out Self.E {
+// CHECK-LABEL: sil hidden @$s28lifetime_dependence_generics1PPAAE10getDefault1EQzyF : $@convention(method) <Self where Self : P> (@in_guaranteed Self) -> @lifetime(borrow address_for_deps 0)  @out Self.E {
 
 // CHECK-LABEL: sil hidden @$s28lifetime_dependence_generics5PViewV4getEAA4ViewVyF : $@convention(method) (PView) -> @lifetime(immortal) @owned View {
 

test/SILGen/lifetime_dependence_lowering.swift

@@ -90,21 +90,21 @@ struct Butt {
 @_addressableForDependencies
 struct AddressableForDeps {
     // CHECK-LABEL: sil{{.*}} @$s{{.*}}6test16{{.*}} : $
-    // CHECK-SAME: -> @lifetime(borrow address 3) @owned Foo
+    // CHECK-SAME: -> @lifetime(borrow address_for_deps 3) @owned Foo
     @lifetime(borrow self)
     func test16(tuple: (AddressableForDeps, AddressableForDeps),
                 other: AddressableForDeps) -> Foo {}
 
     // The dependency makes the tuple pass as a single indirect argument.
     // CHECK-LABEL: sil{{.*}} @$s{{.*}}6test17{{.*}} : $
-    // CHECK-SAME: -> @lifetime(borrow address 0) @owned Foo
+    // CHECK-SAME: -> @lifetime(borrow address_for_deps 0) @owned Foo
     @lifetime(borrow tuple)
     func test17(tuple: (AddressableForDeps, AddressableForDeps),
                 other: AddressableForDeps) -> Foo {}
 
     // The tuple destructures as usual, but `other` is passed indirectly.
     // CHECK-LABEL: sil{{.*}} @$s{{.*}}6test18{{.*}} : $
-    // CHECK-SAME: -> @lifetime(borrow address 2) @owned Foo
+    // CHECK-SAME: -> @lifetime(borrow address_for_deps 2) @owned Foo
     @lifetime(borrow other)
     func test18(tuple: (AddressableForDeps, AddressableForDeps),
                 other: AddressableForDeps) -> Foo {}