UnsafeGuaranteedPeephole: Skip debug instructions and ignore retain/release uses

Author: aschwaighofer

lib/SILOptimizer/Transforms/UnsafeGuaranteedPeephole.cpp

@@ -56,7 +56,11 @@ getSingleUnsafeGuaranteedValueResult(BuiltinInst *BI) {
   auto Failed = std::make_pair(nullptr, nullptr);
 
   for (auto *Operand : getNonDebugUses(BI)) {
-    auto *TE = dyn_cast<TupleExtractInst>(Operand->getUser());
+    auto *Usr = Operand->getUser();
+    if (isa<ReleaseValueInst>(Usr) || isa<RetainValueInst>(Usr))
+      continue;
+
+    auto *TE = dyn_cast<TupleExtractInst>(Usr);
     if (!TE || TE->getOperand() != BI)
       return Failed;
 
@@ -97,13 +101,19 @@ findReleaseToMatchUnsafeGuaranteedValue(SILInstruction *UnsafeGuaranteedEndI,
     return BB.end();
   auto LastReleaseIt = std::prev(UnsafeGuaranteedEndIIt);
   while (LastReleaseIt != BB.begin() &&
-         (isa<StrongReleaseInst>(*LastReleaseIt) ||
-          isa<ReleaseValueInst>(*LastReleaseIt)) &&
-         LastReleaseIt->getOperand(0) != UnsafeGuaranteedValue)
+         (((isa<StrongReleaseInst>(*LastReleaseIt) ||
+            isa<ReleaseValueInst>(*LastReleaseIt)) &&
+           LastReleaseIt->getOperand(0) != UnsafeGuaranteedValue &&
+           LastReleaseIt->getOperand(0) !=
+               cast<SILInstruction>(UnsafeGuaranteedValue)->getOperand(0)) ||
+          isa<DebugValueInst>(*LastReleaseIt) ||
+          isa<DebugValueInst>(*LastReleaseIt)))
     --LastReleaseIt;
   if ((!isa<StrongReleaseInst>(*LastReleaseIt) &&
        !isa<ReleaseValueInst>(*LastReleaseIt)) ||
-      LastReleaseIt->getOperand(0) != UnsafeGuaranteedValue) {
+      (LastReleaseIt->getOperand(0) != UnsafeGuaranteedValue &&
+       LastReleaseIt->getOperand(0) !=
+           cast<SILInstruction>(UnsafeGuaranteedValue)->getOperand(0))) {
     return BB.end();
   }
   return LastReleaseIt;
@@ -145,7 +155,9 @@ static bool removeGuaranteedRetainReleasePairs(SILFunction &F) {
       auto NextInstIter = std::next(SILBasicBlock::iterator(LastRetainInst));
       while (NextInstIter != BB.end() && &*NextInstIter != CurInst &&
              (isa<RetainValueInst>(*NextInstIter) ||
-              isa<StrongRetainInst>(*NextInstIter)))
+              isa<StrongRetainInst>(*NextInstIter) ||
+              isa<DebugValueInst>(*NextInstIter) ||
+              isa<DebugValueAddrInst>(*NextInstIter)))
        ++NextInstIter;
       if (&*NextInstIter != CurInst) {
         DEBUG(llvm::dbgs() << "Last retain right before match failed\n");
@@ -228,6 +240,7 @@ static bool removeGuaranteedRetainReleasePairs(SILFunction &F) {
       UnsafeGuaranteedValue->replaceAllUsesWith(Opd);
       UnsafeGuaranteedValue->eraseFromParent();
       UnsafeGuaranteedToken->eraseFromParent();
+      UnsafeGuaranteedI->replaceAllUsesWith(Opd);
       UnsafeGuaranteedI->eraseFromParent();
 
       if (RestartAtBeginningOfBlock)

test/SILOptimizer/unsafe_guaranteed_peephole.sil

@@ -9,6 +9,7 @@ public class Foo {
 }
 
 sil @beep : $@convention(thin) () -> ()
+sil @beep2 : $@convention(thin) (@owned Foo) -> ()
 
 // CHECK-LABEL: sil @testUnsafeGuaranteed_simple
 // CHECK: bb0([[P:%.*]] : $Foo):
@@ -235,3 +236,57 @@ bb3:
   %20 = apply %19(%5) : $@convention(method) (@guaranteed Foo) -> ()
   br bb2
 }
+
+// CHECK-LABEL: sil @testUnsafeGuaranteed_debug_inst
+// CHECK: bb0([[P:%.*]] : $Foo):
+// CHECK-NOT: retain
+// CHECK-NOT: unsafeGuaranteed
+// CHECK:   [[M:%.*]] = class_method [[P]] : $Foo, #Foo.beep
+// CHECK:   apply [[M]]([[P]])
+// CHECK-NOT: release
+// CHECK-NOT: unsafeGuaranteedEnd
+// CHECK:   [[T:%.*]] = tuple ()
+// CHECK:   return [[T]]
+// CHECK: }
+sil @testUnsafeGuaranteed_debug_inst : $@convention(method) (@guaranteed Foo) -> () {
+bb0(%0 : $Foo):
+  strong_retain %0 : $Foo
+  debug_value %0 : $Foo
+  %4 = builtin "unsafeGuaranteed"<Foo>(%0 : $Foo) : $(Foo, Builtin.Int8)
+  %5 = tuple_extract %4 : $(Foo, Builtin.Int8), 0
+  %6 = tuple_extract %4 : $(Foo, Builtin.Int8), 1
+  %19 = class_method %5 : $Foo, #Foo.beep!1 : (Foo) -> () -> () , $@convention(method) (@guaranteed Foo) -> ()
+  %20 = apply %19(%5) : $@convention(method) (@guaranteed Foo) -> ()
+  strong_release %5 : $Foo
+  debug_value %5 : $Foo
+  %16 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
+  %17 = tuple ()
+  return %17 : $()
+}
+
+// CHECK-LABEL: sil @testUnsafeGuaranteed_retain_release
+// CHECK: bb0([[P:%.*]] : $Foo):
+// CHECK-NOT: strong_retain
+// CHECK-NOT: unsafeGuaranteed
+// CHECK:   retain_value [[P]]
+// CHECK:   [[M:%.*]] = function_ref @beep2
+// CHECK:   apply [[M]]([[P]])
+// CHECK-NOT: release
+// CHECK-NOT: unsafeGuaranteedEnd
+// CHECK:   [[T:%.*]] = tuple ()
+// CHECK:   return [[T]]
+// CHECK: }
+sil @testUnsafeGuaranteed_retain_release : $@convention(method) (@guaranteed Foo) -> () {
+bb0(%0 : $Foo):
+  strong_retain %0 : $Foo
+  %4 = builtin "unsafeGuaranteed"<Foo>(%0 : $Foo) : $(Foo, Builtin.Int8)
+  %5 = tuple_extract %4 : $(Foo, Builtin.Int8), 0
+  %6 = tuple_extract %4 : $(Foo, Builtin.Int8), 1
+  retain_value %4 : $(Foo, Builtin.Int8)
+  %19 = function_ref @beep2 :  $@convention(thin) (@owned Foo) -> ()
+  %20 = apply %19(%5) : $@convention(thin) (@owned Foo) -> ()
+  release_value %4 : $(Foo, Builtin.Int8)
+  %16 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
+  %17 = tuple ()
+  return %17 : $()
+}