Merge pull request swiftlang#30770 from eeckstein/fix-escape-analysis

EscapeAnalysis: fix a problem with unchecked_addr_cast

Author: eeckstein

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -141,7 +141,6 @@ SILValue EscapeAnalysis::getPointerBase(SILValue value) {
   case ValueKind::RefToRawPointerInst:
   case ValueKind::RefToBridgeObjectInst:
   case ValueKind::BridgeObjectToRefInst:
-  case ValueKind::UncheckedAddrCastInst:
   case ValueKind::UnconditionalCheckedCastInst:
     // DO NOT use LOADABLE_REF_STORAGE because unchecked references don't have
     // retain/release instructions that trigger the 'default' case.
@@ -151,6 +150,20 @@ SILValue EscapeAnalysis::getPointerBase(SILValue value) {
 #include "swift/AST/ReferenceStorage.def"
     return cast<SingleValueInstruction>(value)->getOperand(0);
 
+  case ValueKind::UncheckedAddrCastInst: {
+    auto *uac = cast<UncheckedAddrCastInst>(value);
+    SILValue op = uac->getOperand();
+    SILType srcTy = op->getType().getObjectType();
+    SILType destTy = value->getType().getObjectType();
+    SILFunction *f = uac->getFunction();
+    // If the source and destination of the cast don't agree on being a pointer,
+    // we bail. Otherwise we would miss important edges in the connection graph:
+    // e.g. loads of non-pointers are ignored, while it could be an escape of
+    // the value (which could be a pointer before the cast).
+    if (findCachedPointerKind(srcTy, *f) != findCachedPointerKind(destTy, *f))
+      return SILValue();
+    return op;
+  }
   case ValueKind::TupleExtractInst: {
     auto *TEI = cast<TupleExtractInst>(value);
     // Special handling for extracting the pointer-result from an

test/SILOptimizer/Inputs/dse_with_union.h

@@ -0,0 +1,8 @@
+struct S {
+   int i;
+};
+
+union U {
+  struct S *p;
+};
+

test/SILOptimizer/dse_with_union.swift

@@ -0,0 +1,28 @@
+// RUN: %empty-directory(%t) 
+// RUN: %target-build-swift -O %s -import-objc-header %S/Inputs/dse_with_union.h -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test
+
+// Check that EscapeAnalysis does not mess up with a union.
+
+@inline(never)
+func printit(_ u: inout U) {
+  print(u.p![0])
+}
+
+@inline(never)
+func testit(s: S) {
+  var vs = s
+  withUnsafeMutablePointer(to: &vs) {
+    // A C union is an opaque type in swift and not considered as a "pointer"
+    // in escape analysis. Converting between pointer and non-pointer resulted
+    // in a wrong connection graph.
+    var u = U(p: $0)
+    printit(&u)
+  }
+}
+
+// CHECK: S(i: 27)
+testit(s: S(i: 27))
+

test/SILOptimizer/escape_analysis.sil

@@ -1127,6 +1127,23 @@ bb0(%0 : $*U, %1 : $*T, %2 : $@thick U.Type):
   return %5 : $()
 }
 
+// CHECK-LABEL: CG of test_unchecked_addr_cast
+// CHECK-NEXT:    Arg [ref] %0 Esc: G, Succ: 
+// CHECK-NEXT:    Val %1 Esc: , Succ: (%1.1)
+// CHECK-NEXT:    Con [ref] %1.1 Esc: G, Succ: 
+// CHECK-NEXT:    Val %2 Esc: , Succ: (%2.1)
+// CHECK-NEXT:    Con [ref] %2.1 Esc: G, Succ: %0
+// CHECK-NEXT:  End
+sil @test_unchecked_addr_cast : $@convention(thin) (@guaranteed AnyObject) -> Int {
+bb0(%0 : $AnyObject):
+  %1 = alloc_stack $Int
+  %2 = unchecked_addr_cast %1 : $*Int to $*AnyObject
+  store %0 to %2 : $*AnyObject
+  %4 = load %1 : $*Int
+  dealloc_stack %1 : $*Int
+  return %4 : $Int
+}
+
 sil_global @global_y : $SomeData
 
 // CHECK-LABEL: CG of test_node_merge_during_struct_inst