Merge pull request #30265 from gottesmm/pr-8d01937acb91692d7483e6a5895296634037a326

Author: swift-ci

include/swift/SIL/OwnershipUtils.h

@@ -58,6 +58,14 @@ bool isOwnedForwardingValueKind(SILNodeKind kind);
 /// forward guaranteed ownership.
 bool isOwnedForwardingInstruction(SILInstruction *inst);
 
+/// Does this value 'forward' owned ownership, but may not be able to forward
+/// guaranteed ownership.
+///
+/// This will be either a multiple value instruction resuilt, a single value
+/// instruction that forwards or an argument that forwards the ownership from a
+/// previous terminator.
+bool isOwnedForwardingValue(SILValue value);
+
 struct BorrowScopeOperandKind {
   enum Kind {
     BeginBorrow,
@@ -371,13 +379,6 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
 bool getAllBorrowIntroducingValues(
     SILValue value, SmallVectorImpl<BorrowScopeIntroducingValue> &out);
 
-/// Look up the def-use graph starting at \p inputOperand and see if
-/// we can find a single BorrowScopeIntroducingValue for \p
-/// inputOperand. Returns None if there are multiple such introducers
-/// or if while processing we find a user we do not understand.
-Optional<BorrowScopeIntroducingValue>
-getSingleBorrowIntroducingValue(SILValue value);
-
 /// Look up through the def-use chain of \p inputValue, looking for an initial
 /// "borrow" introducing value. If at any point, we find two introducers or we
 /// find a point in the chain we do not understand, we bail and return false. If
@@ -467,6 +468,164 @@ struct InteriorPointerOperand {
       : operand(op), kind(kind) {}
 };
 
+struct OwnedValueIntroducerKind {
+  enum Kind {
+    /// An owned value that is a result of an Apply.
+    Apply,
+
+    /// An owned value returned as a result of applying a begin_apply.
+    BeginApply,
+
+    /// An owned value that is an argument that is in one of the successor
+    /// blocks of a try_apply. This represents in a sense the try applies
+    /// result.
+    TryApply,
+
+    /// An owned value produced as a result of performing a copy_value on some
+    /// other value.
+    Copy,
+
+    /// An owned value produced as a result of performing a load [copy] on a
+    /// memory location.
+    LoadCopy,
+
+    /// An owned value produced as a result of performing a load [take] from a
+    /// memory location.
+    LoadTake,
+
+    /// An owned value that is a result of a true phi argument.
+    ///
+    /// A true phi argument here is defined as an SIL phi argument that only has
+    /// branch predecessors.
+    Phi,
+
+    /// An owned value that is a function argument.
+    FunctionArgument,
+
+    /// An owned value that is a new partial_apply that has been formed.
+    PartialApplyInit,
+
+    /// An owned value from the formation of a new alloc_box.
+    AllocBoxInit,
+
+    /// An owned value from the formataion of a new alloc_ref.
+    AllocRefInit,
+  };
+
+  static Optional<OwnedValueIntroducerKind> get(SILValue value) {
+    if (value.getOwnershipKind() != ValueOwnershipKind::Owned)
+      return None;
+
+    switch (value->getKind()) {
+    default:
+      return None;
+    case ValueKind::ApplyInst:
+      return OwnedValueIntroducerKind(Apply);
+    case ValueKind::BeginApplyResult:
+      return OwnedValueIntroducerKind(BeginApply);
+    case ValueKind::SILPhiArgument: {
+      auto *phiArg = cast<SILPhiArgument>(value);
+      if (dyn_cast_or_null<TryApplyInst>(phiArg->getSingleTerminator())) {
+        return OwnedValueIntroducerKind(TryApply);
+      }
+      if (llvm::all_of(phiArg->getParent()->getPredecessorBlocks(),
+                       [](SILBasicBlock *block) {
+                         return isa<BranchInst>(block->getTerminator());
+                       })) {
+        return OwnedValueIntroducerKind(Phi);
+      }
+      return None;
+    }
+    case ValueKind::SILFunctionArgument:
+      return OwnedValueIntroducerKind(FunctionArgument);
+    case ValueKind::CopyValueInst:
+      return OwnedValueIntroducerKind(Copy);
+    case ValueKind::LoadInst: {
+      auto qual = cast<LoadInst>(value)->getOwnershipQualifier();
+      if (qual == LoadOwnershipQualifier::Take)
+        return OwnedValueIntroducerKind(LoadTake);
+      if (qual == LoadOwnershipQualifier::Copy)
+        return OwnedValueIntroducerKind(LoadCopy);
+      return None;
+    }
+    case ValueKind::PartialApplyInst:
+      return OwnedValueIntroducerKind(PartialApplyInit);
+    case ValueKind::AllocBoxInst:
+      return OwnedValueIntroducerKind(AllocBoxInit);
+    case ValueKind::AllocRefInst:
+      return OwnedValueIntroducerKind(AllocRefInit);
+    }
+    llvm_unreachable("Default should have caught this");
+  }
+
+  Kind value;
+
+  OwnedValueIntroducerKind(Kind newValue) : value(newValue) {}
+  OwnedValueIntroducerKind(const OwnedValueIntroducerKind &other)
+      : value(other.value) {}
+  operator Kind() const { return value; }
+
+  void print(llvm::raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              OwnedValueIntroducerKind kind);
+
+/// A higher level construct for working with values that introduce a new
+/// "owned" value.
+///
+/// An owned "introducer" is a value that signals in a SIL program the begin of
+/// a new semantic @owned ownership construct that is live without respect to
+/// any other values in the function. This introducer value is then either used
+/// directly, forwarded then used, and then finally destroyed.
+///
+/// NOTE: Previous incarnations of this concept used terms like "RC-identity".
+struct OwnedValueIntroducer {
+  /// The actual underlying value that introduces the new owned value.
+  SILValue value;
+
+  /// The kind of "introducer" that we use to classify any of various possible
+  /// underlying introducing values.
+  OwnedValueIntroducerKind kind;
+
+  /// If a value is an owned value introducer we can recognize, return
+  /// .some(OwnedValueIntroducer). Otherwise, return None.
+  static Optional<OwnedValueIntroducer> get(SILValue value) {
+    auto kind = OwnedValueIntroducerKind::get(value);
+    if (!kind)
+      return None;
+    return OwnedValueIntroducer(value, *kind);
+  }
+
+  bool operator==(const OwnedValueIntroducer &other) const {
+    return value == other.value;
+  }
+
+  bool operator!=(const OwnedValueIntroducer &other) const {
+    return !(*this == other);
+  }
+
+  bool operator<(const OwnedValueIntroducer &other) const {
+    return value < other.value;
+  }
+
+private:
+  OwnedValueIntroducer(SILValue value, OwnedValueIntroducerKind kind)
+      : value(value), kind(kind) {}
+};
+
+/// Look up the def-use graph starting at use \p inputOperand, recording any
+/// values that act as "owned" introducers.
+///
+/// NOTE: This may return multiple owned introducers in cases where there are
+/// phi-like nodes in the IR like any true phi block arguments or aggregate
+/// literal instructions (struct, tuple, enum, etc.).
+bool getAllOwnedValueIntroducers(SILValue value,
+                                 SmallVectorImpl<OwnedValueIntroducer> &out);
+
+Optional<OwnedValueIntroducer> getSingleOwnedValueIntroducer(SILValue value);
+
 } // namespace swift
 
 #endif

lib/SIL/OwnershipUtils.cpp

@@ -85,6 +85,17 @@ bool swift::isOwnedForwardingInstruction(SILInstruction *inst) {
   }
 }
 
+bool swift::isOwnedForwardingValue(SILValue value) {
+  switch (value->getKind()) {
+  // Phi arguments always forward ownership.
+  case ValueKind::SILPhiArgument:
+    return true;
+  default:
+    return isOwnedForwardingValueKind(
+        value->getKindOfRepresentativeSILNodeInObject());
+  }
+}
+
 bool swift::isGuaranteedForwardingValue(SILValue value) {
   // If we have an argument from a transforming terminator, we can forward
   // guaranteed.
@@ -95,6 +106,7 @@ bool swift::isGuaranteedForwardingValue(SILValue value) {
       }
     }
   }
+
   return isGuaranteedForwardingValueKind(
       value->getKindOfRepresentativeSILNodeInObject());
 }
@@ -443,6 +455,49 @@ bool BorrowScopeIntroducingValue::visitInteriorPointerOperands(
   return true;
 }
 
+//===----------------------------------------------------------------------===//
+//                          Owned Value Introducers
+//===----------------------------------------------------------------------===//
+
+void OwnedValueIntroducerKind::print(llvm::raw_ostream &os) const {
+  switch (value) {
+  case OwnedValueIntroducerKind::Apply:
+    os << "Apply";
+    return;
+  case OwnedValueIntroducerKind::BeginApply:
+    os << "BeginApply";
+    return;
+  case OwnedValueIntroducerKind::TryApply:
+    os << "TryApply";
+    return;
+  case OwnedValueIntroducerKind::Copy:
+    os << "Copy";
+    return;
+  case OwnedValueIntroducerKind::LoadCopy:
+    os << "LoadCopy";
+    return;
+  case OwnedValueIntroducerKind::LoadTake:
+    os << "LoadTake";
+    return;
+  case OwnedValueIntroducerKind::Phi:
+    os << "Phi";
+    return;
+  case OwnedValueIntroducerKind::FunctionArgument:
+    os << "FunctionArgument";
+    return;
+  case OwnedValueIntroducerKind::PartialApplyInit:
+    os << "PartialApplyInit";
+    return;
+  case OwnedValueIntroducerKind::AllocBoxInit:
+    os << "AllocBoxInit";
+    return;
+  case OwnedValueIntroducerKind::AllocRefInit:
+    os << "AllocRefInit";
+    return;
+  }
+  llvm_unreachable("Covered switch isn't covered");
+}
+
 //===----------------------------------------------------------------------===//
 //                       Introducer Searching Routines
 //===----------------------------------------------------------------------===//
@@ -546,3 +601,103 @@ swift::getSingleBorrowIntroducingValue(SILValue inputValue) {
 
   llvm_unreachable("Should never hit this");
 }
+
+bool swift::getAllOwnedValueIntroducers(
+    SILValue inputValue, SmallVectorImpl<OwnedValueIntroducer> &out) {
+  if (inputValue.getOwnershipKind() != ValueOwnershipKind::Owned)
+    return false;
+
+  SmallVector<SILValue, 32> worklist;
+  worklist.emplace_back(inputValue);
+
+  while (!worklist.empty()) {
+    SILValue value = worklist.pop_back_val();
+
+    // First check if v is an introducer. If so, stash it and continue.
+    if (auto introducer = OwnedValueIntroducer::get(value)) {
+      out.push_back(*introducer);
+      continue;
+    }
+
+    // If v produces .none ownership, then we can ignore it. It is important
+    // that we put this before checking for guaranteed forwarding instructions,
+    // since we want to ignore guaranteed forwarding instructions that in this
+    // specific case produce a .none value.
+    if (value.getOwnershipKind() == ValueOwnershipKind::None)
+      continue;
+
+    // Otherwise if v is an ownership forwarding value, add its defining
+    // instruction
+    if (isOwnedForwardingValue(value)) {
+      if (auto *i = value->getDefiningInstruction()) {
+        llvm::copy(i->getOperandValues(true /*skip type dependent ops*/),
+                   std::back_inserter(worklist));
+        continue;
+      }
+
+      // Otherwise, we should have a block argument that is defined by a single
+      // predecessor terminator.
+      auto *arg = cast<SILPhiArgument>(value);
+      auto *termInst = arg->getSingleTerminator();
+      assert(termInst && termInst->isTransformationTerminator());
+      assert(termInst->getNumOperands() == 1 &&
+             "Transforming terminators should always have a single operand");
+      worklist.push_back(termInst->getAllOperands()[0].get());
+      continue;
+    }
+
+    // Otherwise, this is an introducer we do not understand. Bail and return
+    // false.
+    return false;
+  }
+
+  return true;
+}
+
+Optional<OwnedValueIntroducer>
+swift::getSingleOwnedValueIntroducer(SILValue inputValue) {
+  if (inputValue.getOwnershipKind() != ValueOwnershipKind::Owned)
+    return None;
+
+  SILValue currentValue = inputValue;
+  while (true) {
+    // First check if our initial value is an introducer. If we have one, just
+    // return it.
+    if (auto introducer = OwnedValueIntroducer::get(currentValue)) {
+      return introducer;
+    }
+
+    // Otherwise if v is an ownership forwarding value, add its defining
+    // instruction
+    if (isOwnedForwardingValue(currentValue)) {
+      if (auto *i = currentValue->getDefiningInstruction()) {
+        auto instOps = i->getOperandValues(true /*ignore type dependent ops*/);
+        // If we have multiple incoming values, return .None. We can't handle
+        // this.
+        auto begin = instOps.begin();
+        if (std::next(begin) != instOps.end()) {
+          return None;
+        }
+        // Otherwise, set currentOp to the single operand and continue.
+        currentValue = *begin;
+        continue;
+      }
+
+      // Otherwise, we should have a block argument that is defined by a single
+      // predecessor terminator.
+      auto *arg = cast<SILPhiArgument>(currentValue);
+      auto *termInst = arg->getSingleTerminator();
+      assert(termInst && termInst->isTransformationTerminator());
+      assert(termInst->getNumOperands() == 1 &&
+             "Transformation terminators should only have single operands");
+      currentValue = termInst->getAllOperands()[0].get();
+      continue;
+    }
+
+    // Otherwise, this is an introducer we do not understand. Bail and return
+    // None.
+    return None;
+  }
+
+  llvm_unreachable("Should never hit this");
+}