Merge pull request #80223 from atrick/enable-addressable

atrick · web-flow · commit d97a8cec6476 · 2025-03-24T08:30:01.000-07:00
LifetimeDependence: enable addressable dependencies
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift
@@ -138,7 +138,8 @@ extension LifetimeDependentApply {
       // for consistency, we use yieldAddress if any yielded value is an address.
       let targetKind = beginApply.yieldedValues.contains(where: { $0.type.isAddress })
         ? TargetKind.yieldAddress : TargetKind.yield
-      info.sources.push(LifetimeSource(targetKind: targetKind, convention: .scope(addressable: false),
+      info.sources.push(LifetimeSource(targetKind: targetKind,
+                                       convention: .scope(addressable: false, addressableForDeps: false),
                                        value: beginApply.token))
     }
     for operand in applySite.parameterOperands {
@@ -218,7 +219,7 @@ private extension LifetimeDependentApply.LifetimeSourceInfo {
       bases.append(source.value)
     case .result, .inParameter, .inoutParameter:
       // addressable dependencies directly depend on the incoming address.
-      if context.options.enableAddressDependencies() && source.convention.isAddressable {
+      if context.options.enableAddressDependencies() && source.convention.isAddressable(for: source.value) {
         bases.append(source.value)
         return
       }
diff --git a/SwiftCompilerSources/Sources/SIL/FunctionConvention.swift b/SwiftCompilerSources/Sources/SIL/FunctionConvention.swift
@@ -237,7 +237,7 @@ extension FunctionConvention {
 
 public enum LifetimeDependenceConvention : CustomStringConvertible {
   case inherit
-  case scope(addressable: Bool)
+  case scope(addressable: Bool, addressableForDeps: Bool)
 
   public var isScoped: Bool {
     switch self {
@@ -248,12 +248,12 @@ public enum LifetimeDependenceConvention : CustomStringConvertible {
     }
   }
 
-  public var isAddressable: Bool {
+  public func isAddressable(for value: Value) -> Bool {
     switch self {
     case .inherit:
       return false
-    case let .scope(addressable):
-      return addressable
+    case let .scope(addressable, addressableForDeps):
+      return addressable || (addressableForDeps && value.type.isAddressableForDeps(in: value.parentFunction))
     }
   }
 
@@ -313,7 +313,8 @@ extension FunctionConvention {
       }
       if scope {
         let addressable = bridged.checkAddressable(bridgedIndex(parameterIndex: index))
-        return .scope(addressable: addressable)
+        let addressableForDeps = bridged.checkConditionallyAddressable(bridgedIndex(parameterIndex: index))
+        return .scope(addressable: addressable, addressableForDeps: addressableForDeps)
       }
       return nil
     }
diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/SwiftCompilerSources/Sources/SIL/Type.swift
@@ -92,6 +92,11 @@ public struct Type : TypeProperties, CustomStringConvertible, NoReflectionChildr
 
   public var isMarkedAsImmortal: Bool { bridged.isMarkedAsImmortal() }
 
+  /// True if a value of this type can have its address taken by a lifetime-dependent value.
+  public func isAddressableForDeps(in function: Function) -> Bool {
+    bridged.isAddressableForDeps(function.bridged)
+  }
+
   //===--------------------------------------------------------------------===//
   //                Properties of lowered `SILFunctionType`s
   //===--------------------------------------------------------------------===//
diff --git a/include/swift/AST/IndexSubset.h b/include/swift/AST/IndexSubset.h
@@ -197,6 +197,7 @@ class IndexSubset : public llvm::FoldingSetNode {
 
   bool isSubsetOf(IndexSubset *other) const;
   bool isSupersetOf(IndexSubset *other) const;
+  bool isDisjointWith(IndexSubset *other) const;
 
   IndexSubset *adding(unsigned index, ASTContext &ctx) const;
   IndexSubset *extendingCapacity(ASTContext &ctx,
diff --git a/include/swift/AST/LifetimeDependence.h b/include/swift/AST/LifetimeDependence.h
@@ -250,11 +250,10 @@ class LifetimeDependenceInfo {
     assert(!inheritLifetimeParamIndices ||
            !inheritLifetimeParamIndices->isEmpty());
     assert(!scopeLifetimeParamIndices || !scopeLifetimeParamIndices->isEmpty());
-    assert((!conditionallyAddressableParamIndices
-            || (addressableParamIndices
-                && conditionallyAddressableParamIndices
-                    ->isSubsetOf(addressableParamIndices)))
-     && "conditionally-addressable params not a subset of addressable params?");
+    assert((!addressableParamIndices
+            || !conditionallyAddressableParamIndices
+            || conditionallyAddressableParamIndices->isDisjointWith(
+              addressableParamIndices)));
   }
 
   operator bool() const { return !empty(); }
diff --git a/include/swift/AST/SILOptions.h b/include/swift/AST/SILOptions.h
@@ -333,7 +333,7 @@ class SILOptions {
 
   /// Enable enforcement of lifetime dependencies on addressable arguments.
   /// Temporarily used to bootstrap the AddressableParameters feature.
-  bool EnableAddressDependencies = false;
+  bool EnableAddressDependencies = true;
 
   SILOptions() {}
 
diff --git a/include/swift/Option/FrontendOptions.td b/include/swift/Option/FrontendOptions.td
@@ -1505,6 +1505,9 @@ def platform_availability_inheritance_map_path
 def enable_address_dependencies : Flag<["-"], "enable-address-dependencies">,
   HelpText<"Enable enforcement of lifetime dependencies on addressable values.">;
 
+def disable_address_dependencies : Flag<["-"], "disable-address-dependencies">,
+  HelpText<"Disable enforcement of lifetime dependencies on addressable values.">;
+
 } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]
 
 def disable_experimental_parser_round_trip : Flag<["-"],
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -159,6 +159,7 @@ struct BridgedLifetimeDependenceInfo {
   swift::IndexSubset *_Nullable inheritLifetimeParamIndices;
   swift::IndexSubset *_Nullable scopeLifetimeParamIndices;
   swift::IndexSubset *_Nullable addressableParamIndices;
+  swift::IndexSubset *_Nullable conditionallyAddressableParamIndices;
   SwiftUInt targetIndex;
   bool immortal;
 
@@ -168,6 +169,7 @@ struct BridgedLifetimeDependenceInfo {
   BRIDGED_INLINE bool checkInherit(SwiftInt index) const;
   BRIDGED_INLINE bool checkScope(SwiftInt index) const;
   BRIDGED_INLINE bool checkAddressable(SwiftInt index) const;
+  BRIDGED_INLINE bool checkConditionallyAddressable(SwiftInt index) const;
   BRIDGED_INLINE SwiftInt getTargetIndex() const;
 
   BRIDGED_INLINE BridgedOwnedString getDebugDescription() const;
@@ -259,6 +261,7 @@ struct BridgedType {
   BRIDGED_INLINE bool isExactSuperclassOf(BridgedType t) const;
   BRIDGED_INLINE bool isCalleeConsumedFunction() const;
   BRIDGED_INLINE bool isMarkedAsImmortal() const;
+  BRIDGED_INLINE bool isAddressableForDeps(BridgedFunction f) const;
   BRIDGED_INLINE SwiftInt getCaseIdxOfEnumType(BridgedStringRef name) const;
   BRIDGED_INLINE SwiftInt getNumNominalFields() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getFieldType(SwiftInt idx, BridgedFunction f) const;
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -147,6 +147,8 @@ BridgedLifetimeDependenceInfo::BridgedLifetimeDependenceInfo(swift::LifetimeDepe
     : inheritLifetimeParamIndices(info.getInheritIndices()),
       scopeLifetimeParamIndices(info.getScopeIndices()),
       addressableParamIndices(info.getAddressableIndices()),
+      conditionallyAddressableParamIndices(
+        info.getConditionallyAddressableIndices()),
       targetIndex(info.getTargetIndex()), immortal(info.isImmortal()) {}
 
 SwiftInt BridgedLifetimeDependenceInfoArray::count() const {
@@ -177,6 +179,12 @@ bool BridgedLifetimeDependenceInfo::checkAddressable(SwiftInt index) const {
   return addressableParamIndices && addressableParamIndices->contains(index);
 }
 
+bool BridgedLifetimeDependenceInfo::
+checkConditionallyAddressable(SwiftInt index) const {
+  return conditionallyAddressableParamIndices
+    && conditionallyAddressableParamIndices->contains(index);
+}
+
 SwiftInt BridgedLifetimeDependenceInfo::getTargetIndex() const {
   return targetIndex;
 }
@@ -384,6 +392,10 @@ bool BridgedType::isMarkedAsImmortal() const {
   return unbridged().isMarkedAsImmortal();
 }
 
+bool BridgedType::isAddressableForDeps(BridgedFunction f) const {
+  return unbridged().isAddressableForDeps(*f.getFunction());
+}
+
 SwiftInt BridgedType::getCaseIdxOfEnumType(BridgedStringRef name) const {
   return unbridged().getCaseIdxOfEnumType(name.unbridged());
 }
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -927,6 +927,10 @@ class SILType {
 
   bool isMarkedAsImmortal() const;
 
+  /// True if a value of this type can have its address taken by a
+  /// lifetime-dependent value.
+  bool isAddressableForDeps(const SILFunction &function) const;
+
   /// Returns true if this type is an actor type. Returns false if this is any
   /// other type. This includes distributed actors. To check for distributed
   /// actors and actors, use isAnyActor().
diff --git a/lib/AST/IndexSubset.cpp b/lib/AST/IndexSubset.cpp
@@ -52,6 +52,14 @@ bool IndexSubset::isSupersetOf(IndexSubset *other) const {
   return true;
 }
 
+bool IndexSubset::isDisjointWith(IndexSubset *other) const {
+  assert(capacity == other->capacity);
+  for (auto index : range(numBitWords))
+    if (getBitWord(index) & other->getBitWord(index))
+      return false;
+  return true;
+}
+
 IndexSubset *IndexSubset::adding(unsigned index, ASTContext &ctx) const {
   assert(index < getCapacity());
   if (contains(index))
diff --git a/lib/AST/LifetimeDependence.cpp b/lib/AST/LifetimeDependence.cpp
@@ -63,11 +63,9 @@ std::string LifetimeDependenceInfo::getString() const {
         }
         result += kind;
         if (addressable && addressable->contains(i)) {
-          if (condAddressable && condAddressable->contains(i)) {
-            result += "address_for_deps ";
-          } else {
-            result += "address ";
-          }
+          result += "address ";
+        } else if (condAddressable && condAddressable->contains(i)) {
+          result += "address_for_deps ";
         }
         result += std::to_string(i);
         isFirstSetBit = false;
@@ -1136,7 +1134,6 @@ static std::optional<LifetimeDependenceInfo> checkSILTypeModifiers(
         break;
       case LifetimeDescriptor::IsConditionallyAddressable:
         conditionallyAddressableLifetimeParamIndices.set(index);
-        addressableLifetimeParamIndices.set(index);
         break;
       case LifetimeDescriptor::IsAddressable:
         addressableLifetimeParamIndices.set(index);
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -3110,7 +3110,10 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
         LTOKind.value() == IRGenLLVMLTOKind::None;
 
   
-  Opts.EnableAddressDependencies = Args.hasArg(OPT_enable_address_dependencies);
+  Opts.EnableAddressDependencies =
+    Args.hasFlag(OPT_enable_address_dependencies,
+                 OPT_disable_address_dependencies,
+                 Opts.EnableAddressDependencies);
 
   return false;
 }
diff --git a/lib/SIL/IR/SILFunctionType.cpp b/lib/SIL/IR/SILFunctionType.cpp
@@ -1823,14 +1823,12 @@ class DestructureInputs {
       // is addressable-for-dependencies, then lower it with maximal abstraction
       // as well.
       auto &initialSubstTL = TC.getTypeLowering(origType, substType, expansion);
-      if (initialSubstTL.getRecursiveProperties().isAddressableForDependencies()) {
+      if (initialSubstTL.getRecursiveProperties()
+          .isAddressableForDependencies()) {
         origType = AbstractionPattern::getOpaque();
 
-        // Remember that this lowered parameter is conditionally addressable in
-        // the addressable parameters vector.
-        AddressableLoweredParameters.resize(ParameterMap.size() + 1, false);
-        AddressableLoweredParameters[ParameterMap.size()] = true;
-
+        // Remember that this lowered parameter is conditionally
+        // addressable. Specialization may clear this flag.
         ConditionallyAddressableLoweredParameters
           .resize(ParameterMap.size() + 1, false);
         ConditionallyAddressableLoweredParameters[ParameterMap.size()] = true;
diff --git a/lib/SIL/IR/SILType.cpp b/lib/SIL/IR/SILType.cpp
@@ -1148,6 +1148,13 @@ bool SILType::isMarkedAsImmortal() const {
   return false;
 }
 
+bool SILType::isAddressableForDeps(const SILFunction &function) const {
+  auto contextType =
+    hasTypeParameter() ? function.mapTypeIntoContext(*this) : *this;
+  auto &tl = function.getTypeLowering(contextType);
+  return tl.getRecursiveProperties().isAddressableForDependencies();
+}
+
 intptr_t SILType::getFieldIdxOfNominalType(StringRef fieldName) const {
   auto *nominal = getNominalOrBoundGenericNominal();
   if (!nominal)
diff --git a/test/SILOptimizer/lifetime_dependence/dependence_insertion.swift b/test/SILOptimizer/lifetime_dependence/dependence_insertion.swift

Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,7 @@ extension FunctionConvention {`
`237`	`237`
`238`	`238`	`public enum LifetimeDependenceConvention : CustomStringConvertible {`
`239`	`239`	`case inherit`
`240`		`- case scope(addressable: Bool)`
	`240`	`+ case scope(addressable: Bool, addressableForDeps: Bool)`
`241`	`241`
`242`	`242`	`public var isScoped: Bool {`
`243`	`243`	`switch self {`
`@@ -248,12 +248,12 @@ public enum LifetimeDependenceConvention : CustomStringConvertible {`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
`251`		`- public var isAddressable: Bool {`
	`251`	`+ public func isAddressable(for value: Value) -> Bool {`
`252`	`252`	`switch self {`
`253`	`253`	`case .inherit:`
`254`	`254`	`return false`
`255`		`- case let .scope(addressable):`
`256`		`- return addressable`
	`255`	`+ case let .scope(addressable, addressableForDeps):`
	`256`	`+ return addressable \|\| (addressableForDeps && value.type.isAddressableForDeps(in: value.parentFunction))`
`257`	`257`	`}`
`258`	`258`	`}`
`259`	`259`
`@@ -313,7 +313,8 @@ extension FunctionConvention {`
`313`	`313`	`}`
`314`	`314`	`if scope {`
`315`	`315`	`let addressable = bridged.checkAddressable(bridgedIndex(parameterIndex: index))`
`316`		`- return .scope(addressable: addressable)`
	`316`	`+ let addressableForDeps = bridged.checkConditionallyAddressable(bridgedIndex(parameterIndex: index))`
	`317`	`+ return .scope(addressable: addressable, addressableForDeps: addressableForDeps)`
`317`	`318`	`}`
`318`	`319`	`return nil`
`319`	`320`	`}`