Merge pull request #1662 from gottesmm/inguaranteed_loaded_values_are_guaranteed

[arc] A value loaded from an @in_guaranteed parameter is @guaranteed.

Author: gottesmm

lib/SILOptimizer/ARC/RCStateTransitionVisitors.cpp

@@ -51,6 +51,43 @@ visitAutoreleasePoolCall(ValueBase *V) {
   return DataflowResult(RCStateTransitionDataflowResultKind::NoEffects);
 }
 
+// private helper method since C++ does not have extensions... *sigh*.
+//
+// TODO: This needs a better name.
+template <class ARCState>
+static bool isKnownSafe(BottomUpDataflowRCStateVisitor<ARCState> *State,
+                        SILInstruction *I, SILValue Op) {
+  // If we are running with 'frozen' owned arg releases, check if we have a
+  // frozen use in the side table. If so, this release must be known safe.
+  if (State->FreezeOwnedArgEpilogueReleases)
+    if (auto *OwnedRelease =
+            State->EpilogueReleaseMatcher.getSingleReleaseForArgument(Op))
+      if (I != OwnedRelease)
+        return true;
+
+  // A guaranteed function argument is guaranteed to outlive the function we are
+  // processing. So bottom up for such a parameter, we are always known safe.
+  if (auto *Arg = dyn_cast<SILArgument>(Op)) {
+    if (Arg->isFunctionArg() &&
+        Arg->hasConvention(SILArgumentConvention::Direct_Guaranteed)) {
+      return true;
+    }
+  }
+
+  // If Op is a load from an in_guaranteed parameter, it is guaranteed as well.
+  if (auto *LI = dyn_cast<LoadInst>(Op)) {
+    SILValue RCIdentity = State->RCFI->getRCIdentityRoot(LI->getOperand());
+    if (auto *Arg = dyn_cast<SILArgument>(RCIdentity)) {
+      if (Arg->isFunctionArg() &&
+          Arg->hasConvention(SILArgumentConvention::Indirect_In_Guaranteed)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 template <class ARCState>
 typename BottomUpDataflowRCStateVisitor<ARCState>::DataflowResult
 BottomUpDataflowRCStateVisitor<ARCState>::visitStrongDecrement(ValueBase *V) {
@@ -70,23 +107,8 @@ BottomUpDataflowRCStateVisitor<ARCState>::visitStrongDecrement(ValueBase *V) {
   BottomUpRefCountState &State = DataflowState.getBottomUpRefCountState(Op);
   bool NestingDetected = State.initWithMutatorInst(SetFactory.get(I), RCFI);
 
-  // If we are running with 'frozen' owned arg releases, check if we have a
-  // frozen use in the side table. If so, this release must be known safe.
-  if (FreezeOwnedArgEpilogueReleases) {
-    if (auto *OwnedRelease = EpilogueReleaseMatcher.getSingleReleaseForArgument(Op)) {
-      if (I != OwnedRelease) {
-        State.updateKnownSafe(true);
-      }
-    }
-  }
-
-  // A guaranteed function argument is guaranteed to outlive the function we are
-  // processing. So bottom up for such a parameter, we are always known safe.
-  if (auto *Arg = dyn_cast<SILArgument>(Op)) {
-    if (Arg->isFunctionArg() &&
-        Arg->hasConvention(SILArgumentConvention::Direct_Guaranteed)) {
-      State.updateKnownSafe(true);
-    }
+  if (isKnownSafe(this, I, Op)) {
+    State.updateKnownSafe(true);
   }
 
   DEBUG(llvm::dbgs() << "    REF COUNT DECREMENT! Known Safe: "

test/SILOptimizer/arcsequenceopts.sil

@@ -2130,4 +2130,20 @@ bb0(%0 : $Builtin.NativeObject):
   apply %1(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
   strong_release %0 : $Builtin.NativeObject
   return undef : $()
+}
+
+// CHECK-LABEL: sil @in_guaranteed_always_known_safe_bu : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+// CHECK: strong_retain
+// CHECK-NOT: strong_retain
+// CHECK-NOT: strong_release
+sil @in_guaranteed_always_known_safe_bu : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $*Builtin.NativeObject):
+  %1 = load %0 : $*Builtin.NativeObject
+  strong_retain %1 : $Builtin.NativeObject
+  strong_retain %1 : $Builtin.NativeObject
+  %2 = function_ref @use : $@convention(thin) (Builtin.NativeObject) -> ()
+  apply %2(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
+  apply %2(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
+  strong_release %1 : $Builtin.NativeObject
+  return undef : $()
 }