SIL optimizer: Support begin_cow_mutation and end_cow_mutation in some optimizations.

Mostly this is about "looking through" a begin_cow_mutation or end_cow_mutation.

Author: eeckstein

Diff for: lib/SIL/Utils/InstructionUtils.cpp

@@ -128,7 +128,8 @@ SILValue swift::stripCastsWithoutMarkDependence(SILValue V) {
 
     auto K = V->getKind();
     if (isRCIdentityPreservingCast(K) ||
-        K == ValueKind::UncheckedTrivialBitCastInst) {
+        K == ValueKind::UncheckedTrivialBitCastInst ||
+        K == ValueKind::EndCOWMutationInst) {
       V = cast<SingleValueInstruction>(V)->getOperand(0);
       continue;
     }
@@ -308,7 +309,8 @@ bool swift::onlyAffectsRefCount(SILInstruction *user) {
 }
 
 bool swift::mayCheckRefCount(SILInstruction *User) {
-  return isa<IsUniqueInst>(User) || isa<IsEscapingClosureInst>(User);
+  return isa<IsUniqueInst>(User) || isa<IsEscapingClosureInst>(User) ||
+         isa<BeginCOWMutationInst>(User);
 }
 
 bool swift::isSanitizerInstrumentation(SILInstruction *Instruction) {

Diff for: lib/SIL/Utils/Projection.cpp

@@ -371,10 +371,13 @@ Optional<ProjectionPath> ProjectionPath::getProjectionPath(SILValue Start,
 
   auto Iter = End;
   while (Start != Iter) {
-    Projection AP(Iter);
-    if (!AP.isValid())
-      break;
-    P.Path.push_back(AP);
+    // end_cow_mutation is not a projection, but we want to "see through" it.
+    if (!isa<EndCOWMutationInst>(Iter)) {
+      Projection AP(Iter);
+      if (!AP.isValid())
+        break;
+      P.Path.push_back(AP);
+    }
     Iter = cast<SingleValueInstruction>(*Iter).getOperand(0);
   }
 

Diff for: lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -2285,6 +2285,7 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
     case SILInstructionKind::SelectValueInst:
       analyzeSelectInst(cast<SelectValueInst>(I), ConGraph);
       return;
+    case SILInstructionKind::EndCOWMutationInst:
     case SILInstructionKind::StructInst:
     case SILInstructionKind::TupleInst:
     case SILInstructionKind::EnumInst: {

Diff for: lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -699,6 +699,7 @@ static bool isZeroLoadFromEmptyCollection(LoadInst *LI) {
       case ValueKind::UpcastInst:
       case ValueKind::RawPointerToRefInst:
       case ValueKind::AddressToPointerInst:
+      case ValueKind::EndCOWMutationInst:
         addr = cast<SingleValueInstruction>(addr)->getOperand(0);
         break;
       default:

Diff for: lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -159,6 +159,7 @@ static bool isRLEInertInstruction(SILInstruction *Inst) {
   case SILInstructionKind::CondFailInst:
   case SILInstructionKind::IsEscapingClosureInst:
   case SILInstructionKind::IsUniqueInst:
+  case SILInstructionKind::EndCOWMutationInst:
   case SILInstructionKind::FixLifetimeInst:
   case SILInstructionKind::EndAccessInst:
   case SILInstructionKind::SetDeallocatingInst:

Diff for: test/SILOptimizer/redundant_load_elim.sil

@@ -157,6 +157,19 @@ bb0(%0 : $AB):
   return %5 : $Int                               // id: %15
 }
 
+// CHECK-LABEL: sil hidden @load_forward_across_end_cow_mutation
+// CHECK-NOT: = load
+// CHECK: return %1
+sil hidden @load_forward_across_end_cow_mutation : $@convention(thin) (@owned AB, Int) -> Int {
+bb0(%0 : $AB, %1 : $Int):
+  %2 = ref_element_addr %0 : $AB, #AB.value
+  store %1 to %2 : $*Int
+  %4 = end_cow_mutation %0 : $AB
+  %5 = ref_element_addr %4 : $AB, #AB.value
+  %6 = load %5 : $*Int
+  return %6 : $Int
+}
+
 // CHECK-LABEL: sil hidden @redundant_load_across_fixlifetime_inst
 // CHECK: = load
 // CHECK-NOT: = load