AliasAnalysis: consider a take from an address as an write

Currently we only have load [take] in OSSA which needed to be changed.
(copy_addr is not handled in MemBehavior at all, yet)

Even if the memory is physically not modified, conceptually it's "destroyed" when the value is taken.
Optimizations, like TempRValueOpt rely on this behavior when the check for may-writes.

This fixes a MemoryLifetime failure in TempRValueOpt.

Author: eeckstein

include/swift/SIL/SILInstruction.h

@@ -375,6 +375,12 @@ class SILInstruction
     /// The instruction may read memory.
     MayRead,
     /// The instruction may write to memory.
+    /// This includes destroying or taking from memory (e.g. destroy_addr,
+    /// copy_addr [take], load [take]).
+    /// Although, physically, destroying or taking does not modify the memory,
+    /// it is important to model it is a write. Optimizations must not assume
+    /// that the value stored in memory is still available for loading after
+    /// the memory is destroyed or taken.
     MayWrite,
     /// The instruction may read or write memory.
     MayReadWrite,

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -245,6 +245,10 @@ MemBehavior MemoryBehaviorVisitor::visitLoadInst(LoadInst *LI) {
   if (!mayAlias(LI->getOperand()))
     return MemBehavior::None;
 
+  // A take is modelled as a write. See MemoryBehavior::MayWrite.
+  if (LI->getOwnershipQualifier() == LoadOwnershipQualifier::Take)
+      return MemBehavior::MayReadWrite;
+
   LLVM_DEBUG(llvm::dbgs() << "  Could not prove that load inst does not alias "
                              "pointer. Returning may read.\n");
   return MemBehavior::MayRead;

test/SILOptimizer/mem-behavior-all.sil

@@ -113,6 +113,21 @@ bb0(%0 : $*Builtin.Int32):
   return %val : $Builtin.Int32
 }
 
+// CHECK-LABEL: @testLoadTake
+// CHECK:      PAIR #0.
+// CHECK-NEXT:   %2 = load [take] %0 : $*C
+// CHECK-NEXT:   %0 = argument of bb0 : $*C
+// CHECK-NEXT:   r=1,w=1,se=1
+// CHECK:      PAIR #1.
+// CHECK-NEXT:   %2 = load [take] %0 : $*C
+// CHECK-NEXT:   %1 = argument of bb0 : $*C
+// CHECK-NEXT:   r=0,w=0,se=0
+sil [ossa] @testLoadTake : $@convention(thin) (@in C, @in_guaranteed C) -> @owned C {
+bb0(%0 : $*C, %1 : $*C):
+  %2 = load [take] %0 : $*C
+  return %2 : $C
+}
+
 // ===-----------------------------------------------------------------------===
 // Test the effect of a [deinit] access on a global 'let'
 //

test/SILOptimizer/temp_rvalue_opt.sil

@@ -16,6 +16,11 @@ struct GS<Base> {
 
 class Klass {}
 
+struct Str {
+  var kl: Klass
+  var _value: Builtin.Int64
+}
+
 sil @unknown : $@convention(thin) () -> ()
 
 sil @inguaranteed_user_without_result : $@convention(thin) (@in_guaranteed Klass) -> () {
@@ -33,6 +38,8 @@ bb0(%0 : $*Klass, %1 : $*Klass):
 
 sil @throwing_function : $@convention(thin) (@in_guaranteed Klass) -> ((), @error Error)
 
+sil [ossa] @takeStr : $@convention(thin) (@owned Str) -> ()
+
 ///////////
 // Tests //
 ///////////
@@ -124,6 +131,26 @@ bb0(%0 : $*B, %1 : $*GS<B>):
   return %9999 : $()
 }
 
+// Check that we don't cause a memory lifetime failure with load [take]
+
+// CHECK-LABEL: sil [ossa] @take_from_source
+// CHECK: alloc_stack
+// CHECK: copy_addr
+// CHECK: load
+// CHECK: load
+// CHECK: } // end sil function 'take_from_source'
+sil [ossa] @take_from_source : $@convention(thin) (@in Str) -> @owned Str {
+bb0(%0 : $*Str):
+  %1 = alloc_stack $Str
+  copy_addr %0 to [initialization] %1 : $*Str
+  %3 = load [take] %0 : $*Str
+  %4 = load [copy] %1 : $*Str
+  %f = function_ref @takeStr : $@convention(thin) (@owned Str) -> ()
+  %a = apply %f(%4) : $@convention(thin) (@owned Str) -> ()
+  destroy_addr %1 : $*Str
+  dealloc_stack %1 : $*Str
+  return %3 : $Str
+}
 // CHECK-LABEL: sil @load_in_wrong_block
 // CHECK:      bb0(%0 : $*GS<B>):
 // CHECK-NEXT:   alloc_stack