[semantic-arc-opts] Handle arg extract + copy + borrow + use.

Specifically, now the optimizer can take the following code:

sil @foo: $@convention(thin) (@guaranteed NativeObjectPair) -> () {
bb0(%0 : @guaranteed $NativeObjectPair):
  %1 = struct_extract %0 : $NativeObjectPair, #NativeObjectPair.obj1
  %2 = copy_value %1 : $Builtin.NativeObject
  %3 = begin_borrow %2 : $Builtin.NativeObject
  %foo = function_ref ...
  apply %foo(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
  end_borrow %3 : $Builtin.NativeObject
  destroy_value %2 : $Builtin.NativeObject
  ...
}

and eliminate all ownership instructions. I.e.:

sil @foo: $@convention(thin) (@guaranteed NativeObjectPair) -> () {
bb0(%0 : @guaranteed $NativeObjectPair):
  %1 = struct_extract %0 : $NativeObjectPair, #NativeObjectPair.obj1
  %foo = function_ref ....
  apply %foo(%1)
  ...
}

Before this the optimizer could only eliminate 200 insts in the stdlib. With
this change, we now can eliminate ~7000.

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -114,9 +114,12 @@ bool isGuaranteedForwardingValueKind(SILNodeKind kind);
 
 bool isGuaranteedForwardingValue(SILValue value);
 
+bool isOwnershipForwardingInst(SILInstruction *i);
+
 bool isGuaranteedForwardingInst(SILInstruction *i);
 
-bool isOwnershipForwardingInst(SILInstruction *i);
+bool getUnderlyingBorrowIntroducers(SILValue inputValue,
+                                    SmallVectorImpl<SILValue> &out);
 
 } // namespace swift
 

lib/SIL/OwnershipUtils.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SIL/OwnershipUtils.h"
+#include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILInstruction.h"
 
 using namespace swift;
@@ -75,3 +76,38 @@ bool swift::isGuaranteedForwardingInst(SILInstruction *i) {
 bool swift::isOwnershipForwardingInst(SILInstruction *i) {
   return isOwnershipForwardingValueKind(SILNodeKind(i->getKind()));
 }
+
+bool swift::getUnderlyingBorrowIntroducers(SILValue inputValue,
+                                           SmallVectorImpl<SILValue> &out) {
+  SmallVector<SILValue, 32> worklist;
+  worklist.emplace_back(inputValue);
+
+  while (!worklist.empty()) {
+    SILValue v = worklist.pop_back_val();
+
+    // First check if v is an introducer. If so, stash it and continue.
+    if (isa<SILFunctionArgument>(v) || isa<LoadBorrowInst>(v) ||
+        isa<BeginBorrowInst>(v)) {
+      out.push_back(v);
+      continue;
+    }
+
+    // Otherwise if v is an ownership forwarding value, add its defining
+    // instruction
+    if (isGuaranteedForwardingValue(v)) {
+      auto *i = v->getDefiningInstruction();
+      assert(i);
+      transform(i->getAllOperands(), std::back_inserter(worklist),
+                [](const Operand &op) -> SILValue { return op.get(); });
+      continue;
+    }
+
+    // If v produces any ownership, then we can ignore it. Otherwise, we need to
+    // return false since this is an introducer we do not understand.
+    if (v.getOwnershipKind() != ValueOwnershipKind::Any &&
+        v.getOwnershipKind() != ValueOwnershipKind::Trivial)
+      return false;
+  }
+
+  return true;
+}

lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp

@@ -11,12 +11,12 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "sil-semantic-arc-opts"
+#include "swift/Basic/STLExtras.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILVisitor.h"
-#include "swift/Basic/STLExtras.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
@@ -71,19 +71,20 @@ bool SemanticARCOptVisitor::visitBeginBorrowInst(BeginBorrowInst *bbi) {
   return true;
 }
 
-/// TODO: Add support for begin_borrow, load_borrow.
-static bool canHandleOperand(SILValue operand) {
-  if (auto *arg = dyn_cast<SILFunctionArgument>(operand)) {
-    return arg->getOwnershipKind() == ValueOwnershipKind::Guaranteed;
-  }
+static bool canHandleOperand(SILValue operand, SmallVectorImpl<SILValue> &out) {
+  if (!getUnderlyingBorrowIntroducers(operand, out))
+    return false;
 
-  return false;
+  /// TODO: Add support for begin_borrow, load_borrow.
+  return all_of(out, [](SILValue v) { return isa<SILFunctionArgument>(v); });
 }
 
 static bool performGuaranteedCopyValueOptimization(CopyValueInst *cvi) {
+  SmallVector<SILValue, 16> borrowIntroducers;
+
   // Whitelist the operands that we know how to support and make sure
   // our operand is actually guaranteed.
-  if (!canHandleOperand(cvi->getOperand()))
+  if (!canHandleOperand(cvi->getOperand(), borrowIntroducers))
     return false;
 
   // Then go over all of our uses. Find our destroying instructions
@@ -132,8 +133,8 @@ static bool performGuaranteedCopyValueOptimization(CopyValueInst *cvi) {
   //
   // TODO: When we support begin_borrow/load_borrow a linear linfetime
   // check will be needed here.
-  assert(isa<SILFunctionArgument>(cvi->getOperand()) &&
-         "This code must be updated for begin_borrow/load_borrow?!");
+  assert(all_of(borrowIntroducers,
+                [](SILValue v) { return isa<SILFunctionArgument>(v); }));
 
   // Otherwise, we know that our copy_value/destroy_values are all
   // completely within the guaranteed value scope.

test/SILOptimizer/semantic-arc-opts.sil

@@ -100,16 +100,16 @@ bb0(%0 : @guaranteed $Builtin.NativeObject):
   return %9999 : $()
 }
 
-// CHECK-LABEL: sil @struct_extract_guaranteed_use : $@convention(thin) (@guaranteed NativeObjectPair) -> () {
+// CHECK-LABEL: sil @copy_struct_extract_guaranteed_use : $@convention(thin) (@guaranteed NativeObjectPair) -> () {
 // CHECK: bb0([[ARG:%.*]] : @guaranteed $NativeObjectPair):
 // CHECK-NOT: copy_value
 // CHECK-NOT: begin_borrow
 // CHECK:   [[FIELD:%.*]] = struct_extract [[ARG]]
 // CHECK:   apply {{%.*}}([[FIELD]]) :
 // CHECK-NEXT: tuple
 // CHECK-NEXT: return
-// CHECK: } // end sil function 'struct_extract_guaranteed_use'
-sil @struct_extract_guaranteed_use : $@convention(thin) (@guaranteed NativeObjectPair) -> () {
+// CHECK: } // end sil function 'copy_struct_extract_guaranteed_use'
+sil @copy_struct_extract_guaranteed_use : $@convention(thin) (@guaranteed NativeObjectPair) -> () {
 bb0(%0 : @guaranteed $NativeObjectPair):
   %1 = copy_value %0 : $NativeObjectPair
   %2 = begin_borrow %1 : $NativeObjectPair