Merge pull request swiftlang#39679 from meg-gupta/escapeanossa

Improve OSSA instructions handling in EscapeAnalysis

Author: meg-gupta

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -2097,12 +2097,13 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
     }
   }
 
-  if (isa<StrongReleaseInst>(I) || isa<ReleaseValueInst>(I)) {
+  if (isa<StrongReleaseInst>(I) || isa<ReleaseValueInst>(I) ||
+      isa<DestroyValueInst>(I)) {
     // Treat the release instruction as if it is the invocation
     // of a deinit function.
     if (RecursionDepth < MaxRecursionDepth) {
       // Check if the destructor is known.
-      auto OpV = cast<RefCountingInst>(I)->getOperand(0);
+      auto OpV = I->getOperand(0);
       if (buildConnectionGraphForDestructor(OpV, I, FInfo, BottomUpOrder,
                                             RecursionDepth))
         return;
@@ -2157,10 +2158,21 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
         return isPointer(result);
       }));
       return;
-
+    case SILInstructionKind::BeginBorrowInst:
+    case SILInstructionKind::CopyValueInst: {
+      auto svi = cast<SingleValueInstruction>(I);
+      CGNode *resultNode = ConGraph->getNode(svi);
+      if (CGNode *opNode = ConGraph->getNode(svi->getOperand(0))) {
+        ConGraph->defer(resultNode, opNode);
+        return;
+      }
+      ConGraph->setEscapesGlobal(svi);
+      return;
+    }
 #define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
     case SILInstructionKind::Name##ReleaseInst:
 #include "swift/AST/ReferenceStorage.def"
+    case SILInstructionKind::DestroyValueInst:
     case SILInstructionKind::StrongReleaseInst:
     case SILInstructionKind::ReleaseValueInst: {
       // A release instruction may deallocate the pointer operand. This may

test/SILOptimizer/escape_analysis.sil

@@ -1981,3 +1981,37 @@ bb0 (%0 : $*X):
   return %2 : $()
 }
 
+// CHECK-LABEL: CG of test_localval_ossarefcountinsts
+// CHECK:   Val [ref] %0 Esc: , Succ: (%0.1)
+// CHECK:   Con [int] %0.1 Esc: %2, Succ: (%0.2)
+// CHECK:   Con [ref] %0.2 Esc: %2, Succ:
+// CHECK:   Val [ref] %1 Esc: , Succ: %0
+// CHECK: End
+// CHECK: MayEscape:   %0 = alloc_ref $X
+// CHECK:  to   destroy_value %1 : $X
+// CHECK: MayEscape:   %1 = copy_value %0 : $X
+// CHECK:  to   destroy_value %1 : $X
+sil [ossa] @test_localval_ossarefcountinsts : $@convention(thin) () -> () {
+bb0:
+  %o1 = alloc_ref $X
+  %copy = copy_value %o1 : $X
+  destroy_value %copy : $X
+  dealloc_ref %o1 : $X
+  %2 = tuple()
+  return %2 : $()
+}
+
+// CHECK-LABEL: CG of test_localval_borrowinsts
+// CHECK:   Val [ref] %0 Esc: , Succ:
+// CHECK:   Val [ref] %1 Esc: , Succ: %0
+// CHECK: End
+sil [ossa] @test_localval_borrowinsts : $@convention(thin) () -> () {
+bb0:
+  %o1 = alloc_ref $X
+  %borrow = begin_borrow %o1 : $X
+  end_borrow %borrow : $X
+  dealloc_ref %o1 : $X
+  %2 = tuple()
+  return %2 : $()
+}
+