AliasAnalysis: handle copy_addr in MemBehaviorVisitor.

Only let copy_addr have side effects if the source or destination really aliases with the address in question.

Author: eeckstein

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -174,6 +174,7 @@ class MemoryBehaviorVisitor
 
   MemBehavior visitLoadInst(LoadInst *LI);
   MemBehavior visitStoreInst(StoreInst *SI);
+  MemBehavior visitCopyAddrInst(CopyAddrInst *CAI);
   MemBehavior visitApplyInst(ApplyInst *AI);
   MemBehavior visitTryApplyInst(TryApplyInst *AI);
   MemBehavior visitBuiltinInst(BuiltinInst *BI);
@@ -272,6 +273,34 @@ MemBehavior MemoryBehaviorVisitor::visitStoreInst(StoreInst *SI) {
   return MemBehavior::MayWrite;
 }
 
+MemBehavior MemoryBehaviorVisitor::visitCopyAddrInst(CopyAddrInst *CAI) {
+  // If it's an assign to the destination, a destructor might be called on the
+  // old value. This can have any side effects.
+  // We could also check if it's a trivial type (which cannot have any side
+  // effect on destruction), but such copy_addr instructions are optimized to
+  // load/stores anyway, so it's probably not worth it.
+  if (!CAI->isInitializationOfDest())
+    return MemBehavior::MayHaveSideEffects;
+
+  bool mayWrite = mayAlias(CAI->getDest());
+  bool mayRead = mayAlias(CAI->getSrc());
+  
+  if (mayRead) {
+    if (mayWrite)
+      return MemBehavior::MayReadWrite;
+
+    // A take is modelled as a write. See MemoryBehavior::MayWrite.
+    if (CAI->isTakeOfSrc())
+      return MemBehavior::MayReadWrite;
+
+    return MemBehavior::MayRead;
+  }
+  if (mayWrite)
+    return MemBehavior::MayWrite;
+
+  return MemBehavior::None;
+}
+
 MemBehavior MemoryBehaviorVisitor::visitBuiltinInst(BuiltinInst *BI) {
   // If our callee is not a builtin, be conservative and return may have side
   // effects.

test/SILOptimizer/mem-behavior-all.sil

@@ -183,3 +183,64 @@ bb0(%0 : $*Int64Wrapper):
   %8 = tuple ()
   return %8 : $()
 }
+
+// CHECK-LABEL: @test_copy_addr_initialize
+// CHECK:      PAIR #0.
+// CHECK-NEXT:   copy_addr %1 to [initialization] %0 : $*C
+// CHECK-NEXT:   %0 = argument of bb0 : $*C
+// CHECK-NEXT:   r=0,w=1,se=1
+// CHECK:      PAIR #1.
+// CHECK-NEXT:    copy_addr %1 to [initialization] %0 : $*C
+// CHECK-NEXT:    %1 = argument of bb0 : $*C
+// CHECK-NEXT:    r=1,w=0,se=0
+// CHECK:      PAIR #2.
+// CHECK-NEXT:   copy_addr %1 to [initialization] %0 : $*C
+// CHECK-NEXT:   %2 = argument of bb0 : $*C
+// CHECK-NEXT:   r=0,w=0,se=0
+sil @test_copy_addr_initialize : $@convention(thin) (@inout C, @inout C) -> @out C {
+bb0(%0 : $*C, %1 : $*C, %2: $*C):
+  copy_addr %1 to [initialization] %0 : $*C
+  %6 = tuple ()
+  return %6 : $()
+}
+
+// CHECK-LABEL: @test_copy_addr_assign
+// CHECK:      PAIR #0.
+// CHECK-NEXT:   copy_addr %1 to %0 : $*C
+// CHECK-NEXT:   %0 = argument of bb0 : $*C
+// CHECK-NEXT:   r=1,w=1,se=1
+// CHECK:      PAIR #1.
+// CHECK-NEXT:    copy_addr %1 to %0 : $*C
+// CHECK-NEXT:    %1 = argument of bb0 : $*C
+// CHECK-NEXT:    r=1,w=1,se=1
+// CHECK:      PAIR #2.
+// CHECK-NEXT:   copy_addr %1 to %0 : $*C
+// CHECK-NEXT:   %2 = argument of bb0 : $*C
+// CHECK-NEXT:   r=1,w=1,se=1
+sil @test_copy_addr_assign : $@convention(thin) (@inout C, @inout C, @inout C) -> () {
+bb0(%0 : $*C, %1 : $*C, %2: $*C):
+  copy_addr %1 to %0 : $*C
+  %6 = tuple ()
+  return %6 : $()
+}
+
+// CHECK-LABEL: @test_copy_addr_take
+// CHECK:      PAIR #0.
+// CHECK-NEXT:   copy_addr [take] %1 to [initialization] %0 : $*C
+// CHECK-NEXT:   %0 = argument of bb0 : $*C
+// CHECK-NEXT:   r=0,w=1,se=1
+// CHECK:      PAIR #1.
+// CHECK-NEXT:   copy_addr [take] %1 to [initialization] %0 : $*C
+// CHECK-NEXT:   %1 = argument of bb0 : $*C
+// CHECK-NEXT:   r=1,w=1,se=1
+// CHECK:      PAIR #2.
+// CHECK-NEXT:   copy_addr [take] %1 to [initialization] %0 : $*C
+// CHECK-NEXT:   %2 = argument of bb0 : $*C
+// CHECK-NEXT:   r=0,w=0,se=0
+sil @test_copy_addr_take : $@convention(thin) (@in C, @inout C) -> @out C {
+bb0(%0 : $*C, %1 : $*C, %2: $*C):
+  copy_addr [take] %1 to [initialization] %0 : $*C
+  %6 = tuple ()
+  return %6 : $()
+}
+