Stop getUnderlyingObject at mark_dependence instructions for LSLocations

This helps remove redundant loads from mark_dependence instructions while our projection path can't handle them.

Fix for rdar://27138023

Author: aschwaighofer

include/swift/SIL/InstructionUtils.h

@@ -20,13 +20,18 @@ namespace swift {
 /// Strip off casts/indexing insts/address projections from V until there is
 /// nothing left to strip.
 SILValue getUnderlyingObject(SILValue V);
+SILValue getUnderlyingObjectStopAtMarkDependence(SILValue V);
 
 SILValue stripSinglePredecessorArgs(SILValue V);
 
 /// Return the underlying SILValue after stripping off all casts from the
 /// current SILValue.
 SILValue stripCasts(SILValue V);
 
+/// Return the underlying SILValue after stripping off all casts (but
+/// mark_dependence) from the current SILValue.
+SILValue stripCastsWithoutMarkDependence(SILValue V);
+
 /// Return the underlying SILValue after stripping off all upcasts from the
 /// current SILValue.
 SILValue stripUpCasts(SILValue V);

lib/SIL/InstructionUtils.cpp

@@ -30,6 +30,15 @@ SILValue swift::getUnderlyingObject(SILValue V) {
   }
 }
 
+SILValue swift::getUnderlyingObjectStopAtMarkDependence(SILValue V) {
+  while (true) {
+    SILValue V2 = stripIndexingInsts(stripAddressProjections(stripCastsWithoutMarkDependence(V)));
+    if (V2 == V)
+      return V2;
+    V = V2;
+  }
+}
+
 static bool isRCIdentityPreservingCast(ValueKind Kind) {
   switch (Kind) {
     case ValueKind::UpcastInst:
@@ -88,6 +97,21 @@ SILValue swift::stripSinglePredecessorArgs(SILValue V) {
   }
 }
 
+SILValue swift::stripCastsWithoutMarkDependence(SILValue V) {
+  while (true) {
+    V = stripSinglePredecessorArgs(V);
+
+    auto K = V->getKind();
+    if (isRCIdentityPreservingCast(K) ||
+        K == ValueKind::UncheckedTrivialBitCastInst) {
+      V = cast<SILInstruction>(V)->getOperand(0);
+      continue;
+    }
+
+    return V;
+  }
+}
+
 SILValue swift::stripCasts(SILValue V) {
   while (true) {
     V = stripSinglePredecessorArgs(V);

lib/SILOptimizer/Utils/LoadStoreOptUtils.cpp

@@ -214,7 +214,11 @@ LSLocation::enumerateLSLocation(SILModule *M, SILValue Mem,
     return;
 
   // Construct a Location to represent the memory written by this instruction.
-  SILValue UO = getUnderlyingObject(Mem);
+  // ProjectionPath currently does not handle mark_dependence so stop our
+  // underlying object search at these instructions.
+  // We still get a benefit if we cse mark_dependence instructions and then
+  // merge loads from them.
+  SILValue UO = getUnderlyingObjectStopAtMarkDependence(Mem);
   LSLocation L(UO, ProjectionPath::getProjectionPath(UO, Mem));
 
   // If we can't figure out the Base or Projection Path for the memory location,

test/SILOptimizer/redundant_load_elim.sil

@@ -1146,3 +1146,12 @@ bb0(%0 : $*Builtin.Int64, %1 : $*Builtin.Int64):
   %4 = load %1 : $*Builtin.Int64
   return %4 : $Builtin.Int64
 }
+
+sil @redundant_load_mark_dependence : $@convention(thin) (@inout Builtin.Int64, @guaranteed Builtin.NativeObject) -> (Builtin.Int64, Builtin.Int64) {
+bb0(%0 : $*Builtin.Int64, %1 : $Builtin.NativeObject):
+  %2 = mark_dependence %0 : $*Builtin.Int64 on %1 : $Builtin.NativeObject
+  %4 = load %2 : $*Builtin.Int64
+  %5 = load %2 : $*Builtin.Int64
+  %6 = tuple(%4 : $Builtin.Int64, %5 : $Builtin.Int64)
+  return %6 : $(Builtin.Int64, Builtin.Int64)
+}