---

yaml
---
r: 345903
b: refs/heads/master
c: c74ceec
h: refs/heads/master
i:
  345901: 6eb1121
  345899: 6fd955b
  345895: 0ce99b1
  345887: 5c03d1d

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5d7cb677f125bb6b96dc675e9d9c6696462ec48d
+refs/heads/master: c74ceecc7fcb46dfd1fe2ae451b71c1ef15dc8f0
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/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
 

trunk/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;
+}