[sil-combine] Enable mark_dependence simplifications.

Author: gottesmm

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -2126,49 +2126,64 @@ visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI) {
 }
 
 SILInstruction *SILCombiner::visitMarkDependenceInst(MarkDependenceInst *mdi) {
-  if (mdi->getFunction()->hasOwnership())
-    return nullptr;
+  auto base = lookThroughOwnershipInsts(mdi->getBase());
 
   // Simplify the base operand of a MarkDependenceInst to eliminate unnecessary
   // instructions that aren't adding value.
   //
   // Conversions to Optional.Some(x) often happen here, this isn't important
   // for us, we can just depend on 'x' directly.
-  if (auto *eiBase = dyn_cast<EnumInst>(mdi->getBase())) {
-    if (eiBase->hasOperand() && eiBase->hasOneUse()) {
-      mdi->setBase(eiBase->getOperand());
-      eraseInstFromFunction(*eiBase);
-      return mdi;
+  if (auto *eiBase = dyn_cast<EnumInst>(base)) {
+    if (eiBase->hasOperand()) {
+      auto *use = &mdi->getOperandRef(MarkDependenceInst::Base);
+      OwnershipReplaceSingleUseHelper helper(ownershipFixupContext,
+                                             use, eiBase->getOperand());
+      if (helper) {
+        helper.perform();
+        tryEliminateOnlyOwnershipUsedForwardingInst(eiBase, instModCallbacks);
+        return mdi;
+      }
     }
   }
-  
+
   // Conversions from a class to AnyObject also happen a lot, we can just depend
   // on the class reference.
-  if (auto *ier = dyn_cast<InitExistentialRefInst>(mdi->getBase())) {
-    mdi->setBase(ier->getOperand());
-    if (ier->use_empty())
-      eraseInstFromFunction(*ier);
-    return mdi;
+  if (auto *ier = dyn_cast<InitExistentialRefInst>(base)) {
+    auto *use = &mdi->getOperandRef(MarkDependenceInst::Base);
+    OwnershipReplaceSingleUseHelper helper(ownershipFixupContext,
+                                           use, ier->getOperand());
+    if (helper) {
+      helper.perform();
+      tryEliminateOnlyOwnershipUsedForwardingInst(ier, instModCallbacks);
+      return mdi;
+    }
   }
 
   // Conversions from a class to AnyObject also happen a lot, we can just depend
   // on the class reference.
-  if (auto *oeri = dyn_cast<OpenExistentialRefInst>(mdi->getBase())) {
-    mdi->setBase(oeri->getOperand());
-    if (oeri->use_empty())
-      eraseInstFromFunction(*oeri);
-    return mdi;
+  if (auto *oeri = dyn_cast<OpenExistentialRefInst>(base)) {
+    auto *use = &mdi->getOperandRef(MarkDependenceInst::Base);
+    OwnershipReplaceSingleUseHelper helper(ownershipFixupContext,
+                                           use, oeri->getOperand());
+    if (helper) {
+      helper.perform();
+      tryEliminateOnlyOwnershipUsedForwardingInst(oeri, instModCallbacks);
+      return mdi;
+    }
   }
 
   // Sometimes due to specialization/builtins, we can get a mark_dependence
   // whose base is a trivial typed object. In such a case, the mark_dependence
   // does not have a meaning, so just eliminate it.
   {
-    SILType baseType = mdi->getBase()->getType();
-    if (baseType.isObject() && baseType.isTrivial(*mdi->getFunction())) {
-      SILValue value = mdi->getValue();
-      mdi->replaceAllUsesWith(value);
-      return eraseInstFromFunction(*mdi);
+    SILType baseType = base->getType();
+    if (baseType.isObject()) {
+      if ((hasOwnership() && base.getOwnershipKind() == OwnershipKind::None) ||
+          baseType.isTrivial(*mdi->getFunction())) {
+        SILValue value = mdi->getValue();
+        replaceInstUsesWith(*mdi, value);
+        return eraseInstFromFunction(*mdi);
+      }
     }
   }
 

test/SILOptimizer/sil_combine_ossa.sil

@@ -4139,13 +4139,14 @@ bb2(%5 : @owned $MyErrorType):
   throw %5 : $MyErrorType
 }
 
-// CHECK-LABEL: sil [ossa] @mark_dependence_base
-// XHECK: bb0(
-// XHECK-NOT: init_existential_ref
-// XHECK-NOT: enum
-// XHECK-NEXT: mark_dependence
-// XHECK-NEXT: load
-// XHECK: return
+// CHECK-LABEL: sil [ossa] @mark_dependence_base :
+// CHECK: bb0(
+// CHECK-NOT: init_existential_ref
+// CHECK-NOT: enum
+// CHECK: mark_dependence %0 : $*Builtin.Int64 on {{%.*}} : $B
+// CHECK-NOT: init_existential_ref
+// CHECK-NOT: enum
+// CHECK: } // end sil function 'mark_dependence_base'
 sil [ossa] @mark_dependence_base : $@convention(thin) (@inout Builtin.Int64, @owned B) -> Builtin.Int64 {
 bb0(%0 : $*Builtin.Int64, %1 : @owned $B):
   %x = init_existential_ref %1 : $B : $B, $AnyObject
@@ -4157,10 +4158,10 @@ bb0(%0 : $*Builtin.Int64, %1 : @owned $B):
 }
 
 // CHECK-LABEL: sil [ossa] @mark_dependence_trivial_object_base :
-// XHECK: bb0(
-// XHECK-NEXT: copy_value
-// XHECK-NEXT: return
-// XHECK: } // end sil function 'mark_dependence_trivial_object_base'
+// CHECK: bb0(
+// CHECK-NEXT: copy_value
+// CHECK-NEXT: return
+// CHECK: } // end sil function 'mark_dependence_trivial_object_base'
 sil [ossa] @mark_dependence_trivial_object_base : $@convention(thin) (@guaranteed B) -> @owned B {
 bb0(%0 : @guaranteed $B):
   %0a = copy_value %0 : $B
@@ -4171,13 +4172,14 @@ bb0(%0 : @guaranteed $B):
 
 protocol _NSArrayCore {}
 
-// CHECK-LABEL: sil [ossa] @mark_dependence_base2
-// XHECK: bb0(
-// XHECK-NOT: open_existential_ref
-// XHECK-NOT: enum
-// XHECK-NEXT: mark_dependence
-// XHECK-NEXT: load
-// XHECK: return
+// CHECK-LABEL: sil [ossa] @mark_dependence_base2 :
+// CHECK: bb0(
+// CHECK-NOT: open_existential_ref
+// CHECK-NOT: enum
+// CHECK: mark_dependence %0 : $*Builtin.Int64 on {{%.*}} : $B
+// CHECK-NOT: open_existential_ref
+// CHECK-NOT: enum
+// CHECK: } // end sil function 'mark_dependence_base2'
 sil [ossa] @mark_dependence_base2 : $@convention(thin) (@inout Builtin.Int64, @owned B) -> Builtin.Int64 {
 bb0(%0 : $*Builtin.Int64, %1 : @owned $B):
   %2 = init_existential_ref %1 : $B : $B, $AnyObject