SIL: define a memory-read effect on the mark_dependence base value

If the base value of a mark_dependence is an address, that memory location must be initialized at the mark_dependence.
This requires that the mark_dependence is considered to read from the base address.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -253,6 +253,12 @@ struct AliasAnalysis {
     case let storeBorrow as StoreBorrowInst:
       return memLoc.mayAlias(with: storeBorrow.destination, self) ? .init(write: true) : .noEffects
 
+    case let mdi as MarkDependenceInst:
+      if mdi.base.type.isAddress && memLoc.mayAlias(with: mdi.base, self) {
+        return .init(read: true)
+      }
+      return .noEffects
+
     case let copy as SourceDestAddrInstruction:
       let mayRead = memLoc.mayAlias(with: copy.source, self)
       let mayWrite = memLoc.mayAlias(with: copy.destination, self)

SwiftCompilerSources/Sources/Optimizer/TestPasses/MemBehaviorDumper.swift

@@ -74,6 +74,7 @@ private extension Instruction {
          is CopyAddrInst,
          is BuiltinInst,
          is StoreBorrowInst,
+         is MarkDependenceInst,
          is DebugValueInst:
       return true
     default:

lib/SIL/IR/SILInstruction.cpp

@@ -1081,6 +1081,12 @@ MemoryBehavior SILInstruction::getMemoryBehavior() const {
     llvm_unreachable("Covered switch isn't covered?!");
   }
 
+  if (auto *mdi = dyn_cast<MarkDependenceInst>(this)) {
+    if (mdi->getBase()->getType().isAddress())
+      return MemoryBehavior::MayRead;
+    return MemoryBehavior::None;
+  }
+  
   // TODO: An UncheckedTakeEnumDataAddr instruction has no memory behavior if
   // it is nondestructive. Setting this currently causes LICM to miscompile
   // because access paths do not account for enum projections.

lib/SIL/Utils/MemAccessUtils.cpp

@@ -2829,6 +2829,7 @@ void swift::visitAccessedAddress(SILInstruction *I,
   case SILInstructionKind::EndLifetimeInst:
   case SILInstructionKind::ExistentialMetatypeInst:
   case SILInstructionKind::FixLifetimeInst:
+  case SILInstructionKind::MarkDependenceInst:
   case SILInstructionKind::GlobalAddrInst:
   case SILInstructionKind::HasSymbolInst:
   case SILInstructionKind::HopToExecutorInst:

test/SILOptimizer/mem-behavior.sil

@@ -1851,3 +1851,32 @@ bb0(%0 : @owned $CL):
   %3 = tuple ()
   return %3
 }
+
+// CHECK-LABEL: @test_mark_dependence
+// CHECK:       PAIR #0.
+// CHECK-NEXT:      %3 = mark_dependence %1 : $*C on %2 : $C
+// CHECK-NEXT:    %0 = argument of bb0 : $*C
+// CHECK-NEXT:    r=0,w=0
+// CHECK:       PAIR #3.
+// CHECK-NEXT:      %4 = mark_dependence %2 : $C on %0 : $*C
+// CHECK-NEXT:    %0 = argument of bb0 : $*C
+// CHECK-NEXT:    r=1,w=0
+// CHECK:       PAIR #4.
+// CHECK-NEXT:      %4 = mark_dependence %2 : $C on %0 : $*C
+// CHECK-NEXT:    %1 = argument of bb0 : $*C
+// CHECK-NEXT:    r=0,w=0
+// CHECK:       PAIR #7.
+// CHECK-NEXT:      %5 = mark_dependence %1 : $*C on %0 : $*C
+// CHECK-NEXT:    %0 = argument of bb0 : $*C
+// CHECK-NEXT:    r=1,w=0
+// CHECK:       PAIR #8.
+// CHECK-NEXT:      %5 = mark_dependence %1 : $*C on %0 : $*C
+// CHECK-NEXT:    %1 = argument of bb0 : $*C
+// CHECK-NEXT:    r=0,w=0
+sil [ossa] @test_mark_dependence : $@convention(thin) (@in_guaranteed C, @in_guaranteed C, @owned C) -> @owned C {
+bb0(%0 : $*C, %1 : $*C, %2 : @owned $C):
+  %3 = mark_dependence %1 on %2
+  %4 = mark_dependence %2 on %0
+  %5 = mark_dependence %1 on %0
+  return %4
+}