[sil-combine] Enable unchecked_ref_cast formation from rawpointer_to_ref round trips when compiling with ownership.

Author: gottesmm

lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp

@@ -703,18 +703,45 @@ visitUnconditionalCheckedCastInst(UnconditionalCheckedCastInst *UCCI) {
 }
 
 SILInstruction *
-SILCombiner::
-visitRawPointerToRefInst(RawPointerToRefInst *RawToRef) {
-  if (RawToRef->getFunction()->hasOwnership())
-    return nullptr;
-
+SILCombiner::visitRawPointerToRefInst(RawPointerToRefInst *rawToRef) {
   // (raw_pointer_to_ref (ref_to_raw_pointer x X->Y) Y->Z)
   //   ->
-  // (unchecked_ref_cast X->Z)
-  if (auto *RefToRaw = dyn_cast<RefToRawPointerInst>(RawToRef->getOperand())) {
-    return Builder.createUncheckedRefCast(RawToRef->getLoc(),
-                                          RefToRaw->getOperand(),
-                                          RawToRef->getType());
+  // (unchecked_ref_cast x X->Z)
+  if (auto *refToRaw = dyn_cast<RefToRawPointerInst>(rawToRef->getOperand())) {
+    if (!hasOwnership()) {
+      return Builder.createUncheckedRefCast(
+          rawToRef->getLoc(), refToRaw->getOperand(), rawToRef->getType());
+    }
+
+    // raw_pointer_to_ref produces an unowned value. So we need to handle it
+    // especially with ownership.
+    {
+      SILValue originalRef = refToRaw->getOperand();
+      OwnershipRAUWHelper helper(ownershipFixupContext, rawToRef, originalRef);
+      if (helper) {
+        // We use the refToRaw's insertion point to insert our
+        // unchecked_ref_cast, since we don't know if our guaranteed value
+        SILBuilderWithScope localBuilder(std::next(refToRaw->getIterator()),
+                                         Builder);
+        // Since we are using std::next, we use getAutogeneratedLocation to
+        // avoid any issues if our next insertion point is a terminator.
+        auto loc = RegularLocation::getAutoGeneratedLocation();
+        auto *newInst = localBuilder.createUncheckedRefCast(
+            loc, originalRef, rawToRef->getType());
+        // If we have an operand with ownership, we need to change our
+        // unchecked_ref_cast to produce an unowned value. This is because
+        // otherwise, our unchecked_ref_cast will consume the underlying owned
+        // value, changing a BitwiseEscape to a LifetimeEnding use?! In
+        // contrast, for guaranteed, we are replacing a BitwiseEscape use
+        // (ref_to_rawpointer) with a ForwardedBorrowingUse (unchecked_ref_cast)
+        // which is safe.
+        if (newInst->getOwnershipKind() == OwnershipKind::Owned) {
+          newInst->setOwnershipKind(OwnershipKind::Unowned);
+        }
+        helper.perform(newInst);
+        return nullptr;
+      }
+    }
   }
 
   return nullptr;

test/SILOptimizer/sil_combine_ossa.sil

@@ -1493,14 +1493,15 @@ bb0(%0 : @owned $B):
   return %2 : $F
 }
 
-// We do not support this in OSSA today.
-//
-// CHECK-LABEL: sil [ossa] @unchecked_ref_cast_formation : $@convention(thin) (@owned B) -> @owned F {
-// XHECK: bb0([[INPUT_REF:%[0-9]+]] : @owned $B):
-// XHECK: ref_to_raw_pointer
-// XHECK: raw_pointer_to_ref
-// XHECK: } // end sil function 'unchecked_ref_cast_formation'
-sil [ossa] @unchecked_ref_cast_formation : $@convention(thin) (@owned B) -> @owned F {
+// CHECK-LABEL: sil [ossa] @unchecked_ref_cast_formation_owned : $@convention(thin) (@owned B) -> @owned F {
+// CHECK: bb0([[INPUT_REF:%[0-9]+]] : @owned $B):
+// CHECK-NOT: ref_to_raw_pointer
+// CHECK-NOT: raw_pointer_to_ref
+// CHECK: unchecked_ref_cast
+// CHECK-NOT: ref_to_raw_pointer
+// CHECK-NOT: raw_pointer_to_ref
+// CHECK: } // end sil function 'unchecked_ref_cast_formation_owned'
+sil [ossa] @unchecked_ref_cast_formation_owned : $@convention(thin) (@owned B) -> @owned F {
 bb0(%0 : @owned $B):
   %1 = ref_to_raw_pointer %0 : $B to $Builtin.RawPointer
   %2 = raw_pointer_to_ref %1 : $Builtin.RawPointer to $F
@@ -1509,6 +1510,37 @@ bb0(%0 : @owned $B):
   return %3 : $F
 }
 
+// CHECK-LABEL: sil [ossa] @unchecked_ref_cast_formation_guaranteed : $@convention(thin) (@guaranteed B) -> @owned F {
+// CHECK: bb0([[INPUT_REF:%[0-9]+]] : @guaranteed $B):
+// CHECK-NOT: ref_to_raw_pointer
+// CHECK-NOT: raw_pointer_to_ref
+// CHECK: unchecked_ref_cast
+// CHECK-NOT: ref_to_raw_pointer
+// CHECK-NOT: raw_pointer_to_ref
+// CHECK: } // end sil function 'unchecked_ref_cast_formation_guaranteed'
+sil [ossa] @unchecked_ref_cast_formation_guaranteed : $@convention(thin) (@guaranteed B) -> @owned F {
+bb0(%0 : @guaranteed $B):
+  %1 = ref_to_raw_pointer %0 : $B to $Builtin.RawPointer
+  %2 = raw_pointer_to_ref %1 : $Builtin.RawPointer to $F
+  %3 = copy_value %2 : $F
+  return %3 : $F
+}
+
+// CHECK-LABEL: sil [ossa] @unchecked_ref_cast_formation_unowned : $@convention(thin) (B) -> F {
+// CHECK: bb0([[INPUT_REF:%[0-9]+]] :
+// CHECK-NOT: ref_to_raw_pointer
+// CHECK-NOT: raw_pointer_to_ref
+// CHECK: unchecked_ref_cast
+// CHECK-NOT: ref_to_raw_pointer
+// CHECK-NOT: raw_pointer_to_ref
+// CHECK: } // end sil function 'unchecked_ref_cast_formation_unowned'
+sil [ossa] @unchecked_ref_cast_formation_unowned : $@convention(thin) (B) -> F {
+bb0(%0 : @unowned $B):
+  %1 = ref_to_raw_pointer %0 : $B to $Builtin.RawPointer
+  %2 = raw_pointer_to_ref %1 : $Builtin.RawPointer to $F
+  return %2 : $F
+}
+
 // CHECK-LABEL: sil [ossa] @upcast_unchecked_ref_cast_roundtrip : $@convention(thin) (@owned B) -> @owned B {
 // CHECK-NOT: unchecked_ref_cast
 // CHECK-NOT: upcast