UnsafeGuaranteedPeephole: Use RCIdentityFunctionInfo when matching release

Author: aschwaighofer

lib/SILOptimizer/Transforms/UnsafeGuaranteedPeephole.cpp

@@ -36,6 +36,7 @@
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/Local.h"
 
@@ -92,18 +93,21 @@ getSingleUnsafeGuaranteedValueResult(BuiltinInst *BI) {
 ///    strong_release %6 : $Foo // Ignore.
 ///    %12 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
 ///
-static SILBasicBlock::iterator
-findReleaseToMatchUnsafeGuaranteedValue(SILInstruction *UnsafeGuaranteedEndI,
-                                        SILValue UnsafeGuaranteedValue,
-                                        SILBasicBlock &BB) {
+static SILBasicBlock::iterator findReleaseToMatchUnsafeGuaranteedValue(
+    SILInstruction *UnsafeGuaranteedEndI, SILValue UnsafeGuaranteedValue,
+    SILBasicBlock &BB, RCIdentityFunctionInfo &RCIA) {
+
   auto UnsafeGuaranteedEndIIt = SILBasicBlock::iterator(UnsafeGuaranteedEndI);
   if (UnsafeGuaranteedEndIIt == BB.begin())
     return BB.end();
   auto LastReleaseIt = std::prev(UnsafeGuaranteedEndIIt);
+  auto UnsafeGuaranteedRCIdentityRoot =
+      RCIA.getRCIdentityRoot(UnsafeGuaranteedValue);
   while (LastReleaseIt != BB.begin() &&
          (((isa<StrongReleaseInst>(*LastReleaseIt) ||
             isa<ReleaseValueInst>(*LastReleaseIt)) &&
-           LastReleaseIt->getOperand(0) != UnsafeGuaranteedValue &&
+           RCIA.getRCIdentityRoot(LastReleaseIt->getOperand(0)) !=
+               UnsafeGuaranteedRCIdentityRoot &&
            LastReleaseIt->getOperand(0) !=
                cast<SILInstruction>(UnsafeGuaranteedValue)->getOperand(0)) ||
           !LastReleaseIt->mayHaveSideEffects() ||
@@ -112,7 +116,8 @@ findReleaseToMatchUnsafeGuaranteedValue(SILInstruction *UnsafeGuaranteedEndI,
     --LastReleaseIt;
   if ((!isa<StrongReleaseInst>(*LastReleaseIt) &&
        !isa<ReleaseValueInst>(*LastReleaseIt)) ||
-      (LastReleaseIt->getOperand(0) != UnsafeGuaranteedValue &&
+      (RCIA.getRCIdentityRoot(LastReleaseIt->getOperand(0)) !=
+           UnsafeGuaranteedRCIdentityRoot &&
        LastReleaseIt->getOperand(0) !=
            cast<SILInstruction>(UnsafeGuaranteedValue)->getOperand(0))) {
     return BB.end();
@@ -122,7 +127,8 @@ findReleaseToMatchUnsafeGuaranteedValue(SILInstruction *UnsafeGuaranteedEndI,
 
 /// Remove retain/release pairs around builtin "unsafeGuaranteed" instruction
 /// sequences.
-static bool removeGuaranteedRetainReleasePairs(SILFunction &F) {
+static bool removeGuaranteedRetainReleasePairs(SILFunction &F,
+                                               RCIdentityFunctionInfo &RCIA) {
   bool Changed = false;
   for (auto &BB : F) {
     auto It = BB.begin(), End = BB.end();
@@ -216,7 +222,8 @@ static bool removeGuaranteedRetainReleasePairs(SILFunction &F) {
       // Find the release to match with the unsafeGuaranteedValue.
       auto &UnsafeGuaranteedEndBB = *UnsafeGuaranteedEndI->getParent();
       auto LastReleaseIt = findReleaseToMatchUnsafeGuaranteedValue(
-          UnsafeGuaranteedEndI, UnsafeGuaranteedValue, UnsafeGuaranteedEndBB);
+          UnsafeGuaranteedEndI, UnsafeGuaranteedValue, UnsafeGuaranteedEndBB,
+          RCIA);
       if (LastReleaseIt == UnsafeGuaranteedEndBB.end()) {
         DEBUG(llvm::dbgs() << "  no release before unsafeGuaranteedEnd found\n");
         continue;
@@ -258,7 +265,8 @@ namespace {
 class UnsafeGuaranteedPeephole : public swift::SILFunctionTransform {
 
   void run() override {
-    if (removeGuaranteedRetainReleasePairs(*getFunction()))
+    auto &RCIA = *getAnalysis<RCIdentityAnalysis>()->get(getFunction());
+    if (removeGuaranteedRetainReleasePairs(*getFunction(), RCIA))
       invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
   }
 

test/SILOptimizer/unsafe_guaranteed_peephole.sil

@@ -4,10 +4,14 @@ sil_stage canonical
 import Builtin
 import Swift
 
-public class Foo {
+public class Base {
   public func beep()
 }
 
+public class Foo : Base {
+  public override func beep()
+}
+
 sil @beep : $@convention(thin) () -> ()
 sil @beep2 : $@convention(thin) (@owned Foo) -> ()
 
@@ -367,3 +371,34 @@ bb0(%0 : $Foo, %1: $*Builtin.Int32, %2: $Builtin.Int32):
   %17 = tuple ()
   return %17 : $()
 }
+
+// CHECK-LABEL: sil @testUnsafeGuaranteed_cast_inst
+// CHECK: bb0([[P:%.*]] : $Foo
+// CHECK-NOT: retain
+// CHECK-NOT: unsafeGuaranteed
+// CHECK:  [[U:%.*]] = upcast [[P]] : $Foo to $Base
+// CHECK:   [[M:%.*]] = class_method [[U]] : $Base, #Base.beep
+// CHECK:   apply [[M]]([[U]])
+// CHECK-NOT: release
+// CHECK-NOT: unsafeGuaranteedEnd
+// CHECK:   [[T:%.*]] = tuple ()
+// CHECK:   return [[T]]
+// CHECK: }
+sil @testUnsafeGuaranteed_cast_inst : $@convention(method) (@guaranteed Foo, Builtin.Int32) -> () {
+bb0(%0 : $Foo, %1: $Builtin.Int32):
+  strong_retain %0 : $Foo
+  debug_value %0 : $Foo
+  %3 = struct $MyInt(%1 : $Builtin.Int32)
+  %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
+  %7 = upcast %5 : $Foo to $Base
+  %19 = class_method %7 : $Base, #Base.beep!1 : (Base) -> () -> () , $@convention(method) (@guaranteed Base) -> ()
+  %20 = apply %19(%7) : $@convention(method) (@guaranteed Base) -> ()
+  strong_release %7 : $Base
+  %21 = struct $MyInt(%1 : $Builtin.Int32)
+  debug_value %5 : $Foo
+  %16 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
+  %17 = tuple ()
+  return %17 : $()
+}