[ownership] When RAUWing addresses, do not search for intptrs for addresses rooted in pointer_to_address.

The reason why is that addresses from pointer_to_address never have transitive
interior pointer constraints from where ever the pointer originally came
from. This is the issue that was causing a CSE test to fail, so I added a test
to ossa_rauw_test that works this code path.

Author: gottesmm

include/swift/SIL/InstructionUtils.h

@@ -27,6 +27,10 @@ SILValue getUnderlyingObject(SILValue V);
 
 SILValue getUnderlyingObjectStopAtMarkDependence(SILValue V);
 
+/// Given an address look through address to address projections and indexing
+/// insts.
+SILValue getUnderlyingObjectStoppingAtObjectToAddrProjections(SILValue v);
+
 SILValue stripSinglePredecessorArgs(SILValue V);
 
 /// Return the underlying SILValue after stripping off all casts from the
@@ -55,8 +59,14 @@ SILValue stripClassCasts(SILValue V);
 
 /// Return the underlying SILValue after stripping off all address projection
 /// instructions.
+///
+/// FIXME: Today address projections are referring to the result of the
+/// projection and doesn't consider the operand. Should we change this?
 SILValue stripAddressProjections(SILValue V);
 
+/// Look through any projections that transform an address -> an address.
+SILValue lookThroughAddressToAddressProjections(SILValue v);
+
 /// Return the underlying SILValue after stripping off all aggregate projection
 /// instructions.
 ///

include/swift/SIL/Projection.h

@@ -391,6 +391,10 @@ class Projection {
     }
   }
 
+  static bool isAddressToAddressProjection(SILValue v) {
+    return isAddressProjection(v) && !isObjectToAddressProjection(v);
+  }
+
   /// Returns true if this instruction projects from an object type into an
   /// address subtype.
   static bool isObjectToAddressProjection(SILValue V) {

lib/SIL/Utils/InstructionUtils.cpp

@@ -62,6 +62,20 @@ SILValue swift::getUnderlyingObject(SILValue v) {
   }
 }
 
+SILValue
+swift::getUnderlyingObjectStoppingAtObjectToAddrProjections(SILValue v) {
+  if (!v->getType().isAddress())
+    return SILValue();
+
+  while (true) {
+    auto v2 = lookThroughAddressToAddressProjections(v);
+    v2 = stripIndexingInsts(v2);
+    if (v2 == v)
+      return v2;
+    v = v2;
+  }
+}
+
 SILValue swift::getUnderlyingObjectStopAtMarkDependence(SILValue v) {
   while (true) {
     SILValue v2 = stripCastsWithoutMarkDependence(v);
@@ -207,6 +221,15 @@ SILValue swift::stripAddressProjections(SILValue V) {
   }
 }
 
+SILValue swift::lookThroughAddressToAddressProjections(SILValue v) {
+  while (true) {
+    v = stripSinglePredecessorArgs(v);
+    if (!Projection::isAddressToAddressProjection(v))
+      return v;
+    v = cast<SingleValueInstruction>(v)->getOperand(0);
+  }
+}
+
 SILValue swift::stripValueProjections(SILValue V) {
   while (true) {
     V = stripSinglePredecessorArgs(V);

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -901,28 +901,46 @@ OwnershipRAUWHelper::OwnershipRAUWHelper(OwnershipFixupContext &inputCtx,
   // But if we have an address, we need to check if new value is from an
   // interior pointer or not in a way that the pass understands. What we do is:
   //
-  // 1. Compute the AccessPathWithBase of newValue. If we do not get back a
+  // 1. Early exit some cases that we know can never have interior pointers.
+  //
+  // 2. Compute the AccessPathWithBase of newValue. If we do not get back a
   //    valid such object, invalidate and then bail.
   //
-  // 2. Then we check if the base address is the result of an interior pointer
+  // 3. Then we check if the base address is the result of an interior pointer
   //    instruction. If we do not find one we bail.
   //
-  // 3. Then grab the base value of the interior pointer operand. We only
+  // 4. Then grab the base value of the interior pointer operand. We only
   //    support cases where we have a single BorrowedValue as our base. This is
   //    a safe future proof assumption since one reborrows are on
   //    structs/tuple/destructures, a guaranteed value will always be associated
   //    with a single BorrowedValue, so this will never fail (and the code will
   //    probably be DCEed).
   //
-  // 4. Then we compute an AccessPathWithBase for oldValue and then find its
+  // 5. Then we compute an AccessPathWithBase for oldValue and then find its
   //    derived uses. If we fail, we bail.
   //
-  // 5. At this point, we know that we can perform this RAUW. The only question
+  // 6. At this point, we know that we can perform this RAUW. The only question
   //    is if we need to when we RAUW copy the interior pointer base value. We
   //    perform this check by making sure all of the old value's derived uses
   //    are within our BorrowedValue's scope. If so, we clear the extra state we
   //    were tracking (the interior pointer/oldValue's transitive uses), so we
   //    perform just a normal RAUW (without inserting the copy) when we RAUW.
+  //
+  // We can always RAUW an address with a pointer_to_address since if there
+  // were any interior pointer constraints on whatever address pointer came
+  // from, the address_to_pointer producing that value erases that
+  // information, so we can RAUW without worrying.
+  //
+  // NOTE: We also need to handle this here since a pointer_to_address is not a
+  // valid base value for an access path since it doesn't refer to any storage.
+  {
+    auto baseProj =
+        getUnderlyingObjectStoppingAtObjectToAddrProjections(newValue);
+    if (isa<PointerToAddressInst>(baseProj)) {
+      return;
+    }
+  }
+
   auto accessPathWithBase = AccessPathWithBase::compute(newValue);
   if (!accessPathWithBase.base) {
     // Invalidate!

test/SILOptimizer/ossa_rauw_tests.sil

@@ -973,3 +973,23 @@ bb4:
   destroy_value %0 : $Klass
   return %3 : $Builtin.NativeObject
 }
+
+// Make sure that we always RAUW if our new value address is from a
+// pointer_to_address since we don't track interior pointers that escape through
+// address_to_pointer.
+//
+// CHECK-LABEL: sil [ossa] @interior_pointer_no_base_new_value : $@convention(thin) (Builtin.RawPointer, Builtin.Word) -> @owned Builtin.NativeObject {
+// CHECK: pointer_to_address
+// CHECK-NOT: address_to_pointer
+// CHECK-NOT: pointer_to_address
+// CHECK: } // end sil function 'interior_pointer_no_base_new_value'
+sil [ossa] @interior_pointer_no_base_new_value : $@convention(thin) (Builtin.RawPointer, Builtin.Word) -> @owned Builtin.NativeObject {
+bb0(%0 : $Builtin.RawPointer, %count : $Builtin.Word):
+  %0a = index_raw_pointer %0 : $Builtin.RawPointer, %count : $Builtin.Word
+  %2 = pointer_to_address %0a : $Builtin.RawPointer to [strict] $*Builtin.NativeObject
+  %3 = index_addr %2 : $*Builtin.NativeObject, %count : $Builtin.Word
+  %4 = address_to_pointer %3 : $*Builtin.NativeObject to $Builtin.RawPointer
+  %5 = pointer_to_address %4 : $Builtin.RawPointer to [strict] $*Builtin.NativeObject
+  %6 = load [copy] %5 : $*Builtin.NativeObject
+  return %6 : $Builtin.NativeObject
+}