Add SILFunctionType::isAddressable & ApplySite::isAddressable.

(cherry picked from commit 501abb0)

Author: atrick

include/swift/AST/LifetimeDependence.h

@@ -316,11 +316,6 @@ class LifetimeDependenceInfo {
       && scopeLifetimeParamIndices->contains(index);
   }
 
-  bool checkAddressable(int index) const {
-    return hasAddressableParamIndices()
-      && getAddressableIndices()->contains(index);
-  }
-
   std::string getString() const;
   void Profile(llvm::FoldingSetNodeID &ID) const;
   void getConcatenatedData(SmallVectorImpl<bool> &concatenatedData) const;

include/swift/AST/Types.h

@@ -5649,6 +5649,13 @@ class SILFunctionType final
     return getLifetimeDependenceFor(getNumParameters());
   }
 
+  /// Return true of the specified parameter is addressable based on its type
+  /// lowering in 'caller's context. This includes @_addressableForDependencies
+  /// parameter types.
+  ///
+  /// Defined in SILType.cpp.
+  bool isAddressable(unsigned paramIdx, SILFunction *caller);
+
   /// Returns true if the function type stores a Clang type that cannot
   /// be derived from its Swift type. Returns false otherwise, including if
   /// the function type is not @convention(c) or @convention(block).

include/swift/SIL/ApplySite.h

@@ -641,6 +641,10 @@ class ApplySite {
     return getArgumentParameterInfo(oper).hasOption(SILParameterInfo::Sending);
   }
 
+  /// Return true if 'operand' is addressable after type substitution in the
+  /// caller's context.
+  bool isAddressable(const Operand &operand) const;
+
   static ApplySite getFromOpaqueValue(void *p) { return ApplySite(p); }
 
   friend bool operator==(ApplySite lhs, ApplySite rhs) {

lib/SIL/IR/ApplySite.cpp

@@ -45,3 +45,12 @@ void ApplySite::insertAfterApplication(
   llvm_unreachable("covered switch isn't covered");
 }
 
+bool ApplySite::isAddressable(const Operand &operand) const {
+  unsigned calleeArgIndex = getCalleeArgIndex(operand);
+  assert(calleeArgIndex >= getSubstCalleeConv().getSILArgIndexOfFirstParam());
+  unsigned paramIdx =
+    calleeArgIndex - getSubstCalleeConv().getSILArgIndexOfFirstParam();
+
+  CanSILFunctionType calleeType = getSubstCalleeType();
+  return calleeType->isAddressable(paramIdx, getFunction());
+}

lib/SIL/IR/SILType.cpp

@@ -706,6 +706,29 @@ bool SILFunctionType::isNoReturnFunction(SILModule &M,
   return false;
 }
 
+bool SILFunctionType::isAddressable(unsigned paramIdx, SILFunction *caller) {
+  SILParameterInfo paramInfo = getParameters()[paramIdx];
+  for (auto &depInfo : getLifetimeDependencies()) {
+    auto *addressableIndices = depInfo.getAddressableIndices();
+    if (addressableIndices && addressableIndices->contains(paramIdx)) {
+      return true;
+    }
+    auto *condAddressableIndices = depInfo.getConditionallyAddressableIndices();
+    if (condAddressableIndices && condAddressableIndices->contains(paramIdx)) {
+      CanType argType = paramInfo.getArgumentType(
+        caller->getModule(), this, caller->getTypeExpansionContext());
+      CanType contextType =
+        argType->hasTypeParameter()
+        ? caller->mapTypeIntoContext(argType)->getCanonicalType()
+        : argType;
+      auto &tl = caller->getTypeLowering(contextType);
+      if (tl.getRecursiveProperties().isAddressableForDependencies())
+        return true;
+    }
+  }
+  return false;
+}
+
 #ifndef NDEBUG
 static bool areOnlyAbstractionDifferent(CanType type1, CanType type2) {
   assert(type1->isLegalSILType());