[ownership] Treat mark_dependence as forwarding in its first parameter.

Previously, we only did this for the first parameter if it was converting from
escape to no-escape. We want to /always/ do this.

Author: gottesmm

include/swift/SIL/SILInstruction.h

@@ -6192,8 +6192,12 @@ class UncheckedOwnershipConversionInst
   }
 };
 
-/// MarkDependenceInst - Marks that one value depends on another for
-/// validity in a non-obvious way.
+/// Indicates that the validity of the first operand ("the value") depends on
+/// the value of the second operand ("the base").  Operations that would destroy
+/// the base must not be moved before any instructions which depend on the
+/// result of this instruction, exactly as if the address had been obviously
+/// derived from that operand (e.g. using ``ref_element_addr``). The result is
+/// always equal to the first operand.
 class MarkDependenceInst
     : public InstructionBase<SILInstructionKind::MarkDependenceInst,
                              SingleValueInstruction> {
@@ -6209,6 +6213,7 @@ class MarkDependenceInst
   enum { Value, Base };
 
   SILValue getValue() const { return Operands[Value].get(); }
+
   SILValue getBase() const { return Operands[Base].get(); }
 
   void setValue(SILValue newVal) {

lib/SIL/OperandOwnership.cpp

@@ -859,19 +859,19 @@ OperandOwnershipKindClassifier::visitCopyBlockWithoutEscapingInst(
 
 OperandOwnershipKindMap OperandOwnershipKindClassifier::visitMarkDependenceInst(
     MarkDependenceInst *mdi) {
+  // If we are analyzing "the value", we forward ownership.
+  if (getValue() == mdi->getValue()) {
+    auto kind = getValue().getOwnershipKind();
+    if (kind == ValueOwnershipKind::Any)
+      return Map::allLive();
+    auto lifetimeConstraint = kind.getForwardingLifetimeConstraint();
+    return Map::compatibilityMap(kind, lifetimeConstraint);
+  }
 
-  // Forward ownership if the mark_dependence instruction marks a dependence
-  // on a @noescape function type for an escaping function type.
-  if (getValue() == mdi->getValue())
-    if (auto resFnTy = mdi->getType().getAs<SILFunctionType>())
-      if (auto baseFnTy = mdi->getBase()->getType().getAs<SILFunctionType>())
-        if (!resFnTy->isNoEscape() && baseFnTy->isNoEscape())
-          return Map::compatibilityMap(
-              ValueOwnershipKind::Owned,
-              UseLifetimeConstraint::MustBeInvalidated);
-
-  // We always treat mark dependence as a use that keeps a value alive. We will
-  // be introducing a begin_dependence/end_dependence version of this later.
+  // If we are not the "value" of the mark_dependence, then we must be the
+  // "base". This means that any use that would destroy "value" can not be moved
+  // before any uses of "base". We treat this as non-consuming and rely on the
+  // rest of the optimizer to respect the movement restrictions.
   return Map::allLive();
 }
 

test/SIL/ownership-verifier/use_verifier.sil

@@ -1127,3 +1127,11 @@ bb0:
   return %9999 : $()
 }
 
+sil [ossa] @mark_dependence_test_2 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject):
+  %2 = mark_dependence %0 : $Builtin.NativeObject on %1 : $Builtin.NativeObject
+  destroy_value %1 : $Builtin.NativeObject
+  destroy_value %2 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}