[ownership] Extract out from SILOwnershipVerifier the OperandOwnershipKindMapClassifier

NOTE: This is not the final form of how operand ownership restraints will be
represented. This patch is instead an incremental change that extracts out this
functionality from the ownership verifier as a pure refactor.

rdar://44667493

Author: gottesmm

include/swift/SIL/ApplySite.h

@@ -1,4 +1,4 @@
-//===--- ApplySite.h ------------------------------------------------------===//
+//===--- ApplySite.h -------------------------------------*- mode: c++ -*--===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -459,6 +459,18 @@ class FullApplySite : public ApplySite {
     return getArguments().slice(getNumIndirectSILResults());
   }
 
+  /// Returns true if \p op is the callee operand of this apply site
+  /// and not an argument operand.
+  bool isCalleeOperand(const Operand &op) const {
+    return op.getOperandNumber() < getOperandIndexOfFirstArgument();
+  }
+
+  /// Returns true if \p op is an operand that passes an indirect
+  /// result argument to the apply site.
+  bool isIndirectResultOperand(const Operand &op) const {
+    return getCalleeArgIndex(op) < getNumIndirectSILResults();
+  }
+
   static FullApplySite getFromOpaqueValue(void *p) { return FullApplySite(p); }
 
   static bool classof(const SILInstruction *inst) {

include/swift/SIL/OwnershipUtils.h

@@ -64,26 +64,26 @@ struct ErrorBehaviorKind {
 /// so types/etc do not leak.
 struct OwnershipChecker {
   /// The list of regular users from the last run of the checker.
-  SmallVector<SILInstruction *, 16> RegularUsers;
+  SmallVector<SILInstruction *, 16> regularUsers;
 
   /// The list of regular users from the last run of the checker.
-  SmallVector<SILInstruction *, 16> LifetimeEndingUsers;
+  SmallVector<SILInstruction *, 16> lifetimeEndingUsers;
 
   /// The live blocks for the SILValue we processed. This can be used to
   /// determine if a block is in the "live" region of our SILInstruction.
-  SmallPtrSet<SILBasicBlock *, 32> LiveBlocks;
+  SmallPtrSet<SILBasicBlock *, 32> liveBlocks;
 
   /// The list of implicit regular users from the last run of the checker.
   ///
   /// This is used to encode end of scope like instructions.
-  SmallVector<SILInstruction *, 4> ImplicitRegularUsers;
+  SmallVector<SILInstruction *, 4> endScopeRegularUsers;
 
   /// The module that we are in.
-  SILModule &Mod;
+  SILModule &mod;
 
   /// A cache of dead-end basic blocks that we use to determine if we can
   /// ignore "leaks".
-  DeadEndBlocks &DEBlocks;
+  DeadEndBlocks &deadEndBlocks;
 
   bool checkValue(SILValue Value);
 };
@@ -98,7 +98,7 @@ bool valueHasLinearLifetime(SILValue value,
                             ArrayRef<BranchPropagatedUser> consumingUses,
                             ArrayRef<BranchPropagatedUser> nonConsumingUses,
                             SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-                            DeadEndBlocks &deBlocks,
+                            DeadEndBlocks &deadEndBlocks,
                             ownership::ErrorBehaviorKind errorBehavior);
 
 } // namespace swift

include/swift/SIL/SILValue.h

@@ -55,6 +55,33 @@ static inline llvm::hash_code hash_value(ValueKind K) {
   return llvm::hash_value(size_t(K));
 }
 
+/// What constraint does the given use of an SSA value put on the lifetime of
+/// the given SSA value.
+///
+/// There are two possible constraints: MustBeLive and
+/// MustBeInvalidated. MustBeLive means that the SSA value must be able to be
+/// used in a valid way at the given use point. MustBeInvalidated means that any
+/// use of given SSA value after this instruction on any path through this
+/// instruction.
+enum class UseLifetimeConstraint {
+  /// This use requires the SSA value to be live after the given instruction's
+  /// execution.
+  MustBeLive,
+
+  /// This use invalidates the given SSA value.
+  ///
+  /// This means that the given SSA value can not have any uses that are
+  /// reachable from this instruction. When a value has owned semantics this
+  /// means the SSA value is destroyed at this point. When a value has
+  /// guaranteed (i.e. shared borrow) semantics this means that the program
+  /// has left the scope of the borrowed SSA value and said value can not be
+  /// used.
+  MustBeInvalidated,
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              UseLifetimeConstraint constraint);
+
 /// A value representing the specific ownership semantics that a SILValue may
 /// have.
 struct ValueOwnershipKind {
@@ -64,27 +91,23 @@ struct ValueOwnershipKind {
     /// with Trivial ownership kind can be used. Other side effects (e.g. Memory
     /// dependencies) must still be respected. A SILValue with Trivial ownership
     /// kind must be of Trivial SILType (i.e. SILType::isTrivial(SILModule &)
-    /// must
-    /// return true).
+    /// must return true).
     ///
     /// Some examples of SIL types with Trivial ownership are: Builtin.Int32,
     /// Builtin.RawPointer, aggregates containing all trivial types.
     Trivial,
 
     /// A SILValue with `Unowned` ownership kind is an independent value that
-    /// has
-    /// a lifetime that is only guaranteed to last until the next program
-    /// visible
-    /// side-effect. To maintain the lifetime of an unowned value, it must be
-    /// converted to an owned representation via a copy_value.
+    /// has a lifetime that is only guaranteed to last until the next program
+    /// visible side-effect. To maintain the lifetime of an unowned value, it
+    /// must be converted to an owned representation via a copy_value.
     ///
     /// Unowned ownership kind occurs mainly along method/function boundaries in
     /// between Swift and Objective-C code.
     Unowned,
 
     /// A SILValue with `Owned` ownership kind is an independent value that has
-    /// an
-    /// ownership independent of any other ownership imbued within it. The
+    /// an ownership independent of any other ownership imbued within it. The
     /// SILValue must be paired with a consuming operation that ends the SSA
     /// value's lifetime exactly once along all paths through the program.
     Owned,
@@ -105,10 +128,9 @@ struct ValueOwnershipKind {
     Guaranteed,
 
     /// A SILValue with undefined ownership. It can pair with /Any/ ownership
-    /// kinds . This means that it could take on /any/ ownership semantics. This
+    /// kinds. This means that it could take on /any/ ownership semantics. This
     /// is meant only to model SILUndef and to express certain situations where
-    /// we
-    /// use unqualified ownership. Expected to tighten over time.
+    /// we use unqualified ownership. Expected to tighten over time.
     Any,
 
     LastValueOwnershipKind = Any,
@@ -151,6 +173,23 @@ struct ValueOwnershipKind {
   ValueOwnershipKind getProjectedOwnershipKind(SILModule &M,
                                                SILType Proj) const;
 
+  /// Return the lifetime constraint semantics for this
+  /// ValueOwnershipKind when forwarding ownership.
+  ///
+  /// This is MustBeInvalidated for Owned and MustBeLive for all other ownership
+  /// kinds.
+  UseLifetimeConstraint getForwardingLifetimeConstraint() const {
+    switch (Value) {
+    case ValueOwnershipKind::Trivial:
+    case ValueOwnershipKind::Any:
+    case ValueOwnershipKind::Guaranteed:
+    case ValueOwnershipKind::Unowned:
+      return UseLifetimeConstraint::MustBeLive;
+    case ValueOwnershipKind::Owned:
+      return UseLifetimeConstraint::MustBeInvalidated;
+    }
+  }
+
   /// Returns true if \p Other can be merged successfully with this, implying
   /// that the two ownership kinds are "compatibile".
   ///
@@ -347,6 +386,149 @@ class SILValue {
                        DeadEndBlocks *DEBlocks = nullptr) const;
 };
 
+/// A map from a ValueOwnershipKind that an operand can accept to a
+/// UseLifetimeConstraint that describes the effect that the operand's use has
+/// on the underlying value. If a ValueOwnershipKind is not in this map then
+/// matching an operand with the value results in an ill formed program.
+///
+/// So for instance, a map could specify that if a value is used as an owned
+/// parameter, then the use implies that the original value is destroyed at that
+/// point. In contrast, if the value is used as a guaranteed parameter, then the
+/// liveness constraint just requires that the value remains alive at the use
+/// point.
+struct OperandOwnershipKindMap {
+  // One bit for if a value exists and if the value exists, what the
+  // ownership constraint is. These are stored as pairs.
+  //
+  // NOTE: We are burning 1 bit per unset value. But this is without
+  // matter since we are always going to need less bits than 64, so we
+  // should always have a small case SmallBitVector, so there is no
+  // difference in size.
+  static constexpr unsigned NUM_DATA_BITS =
+      2 * (unsigned(ValueOwnershipKind::LastValueOwnershipKind) + 1);
+
+  /// A bit vector representing our "map". Given a ValueOwnershipKind k, if the
+  /// operand can accept k, the unsigned(k)*2 bit will be set to true. Assuming
+  /// that bit is set, the unsigned(k)*2+1 bit is set to the use lifetime
+  /// constraint provided by the value.
+  SmallBitVector data;
+
+  OperandOwnershipKindMap() : data(NUM_DATA_BITS) {}
+  OperandOwnershipKindMap(ValueOwnershipKind kind,
+                          UseLifetimeConstraint constraint)
+      : data(NUM_DATA_BITS) {
+    add(kind, constraint);
+  }
+
+  /// Return the OperandOwnershipKindMap that tests for compatibility with
+  /// ValueOwnershipKind kind. This means that it will accept a element whose
+  /// ownership is ValueOwnershipKind::Any.
+  static OperandOwnershipKindMap
+  compatibilityMap(ValueOwnershipKind kind, UseLifetimeConstraint constraint) {
+    OperandOwnershipKindMap set;
+    set.addCompatibilityConstraint(kind, constraint);
+    return set;
+  }
+
+  /// Return a map that is compatible with any and all ValueOwnershipKinds
+  /// except for \p kind.
+  static OperandOwnershipKindMap
+  compatibleWithAllExcept(ValueOwnershipKind kind) {
+    OperandOwnershipKindMap map;
+    unsigned index = 0;
+    unsigned end = unsigned(ValueOwnershipKind::LastValueOwnershipKind) + 1;
+    for (; index != end; ++index) {
+      if (ValueOwnershipKind(index) == kind) {
+        continue;
+      }
+      map.add(ValueOwnershipKind(index), UseLifetimeConstraint::MustBeLive);
+    }
+    return map;
+  }
+
+  /// Create a map that has compatibility constraints for each of the
+  /// ValueOwnershipKind, UseLifetimeConstraints in \p args.
+  static OperandOwnershipKindMap
+  compatibilityMap(std::initializer_list<
+                   std::pair<ValueOwnershipKind, UseLifetimeConstraint>>
+                       args) {
+    OperandOwnershipKindMap map;
+    for (auto &p : args) {
+      map.addCompatibilityConstraint(p.first, p.second);
+    }
+    return map;
+  }
+
+  /// Return a map that states that an operand can take any ownership with each
+  /// ownership having a must be live constraint.
+  static OperandOwnershipKindMap allLive() {
+    OperandOwnershipKindMap map;
+    unsigned index = 0;
+    unsigned end = unsigned(ValueOwnershipKind::LastValueOwnershipKind) + 1;
+    while (index != end) {
+      map.add(ValueOwnershipKind(index), UseLifetimeConstraint::MustBeLive);
+      ++index;
+    }
+    return map;
+  }
+
+  /// Specify that the operand associated with this set can accept a value with
+  /// ValueOwnershipKind \p kind. The value provided by the operand will have a
+  /// new ownership enforced constraint defined by \p constraint.
+  void add(ValueOwnershipKind kind, UseLifetimeConstraint constraint) {
+    unsigned index = unsigned(kind);
+    unsigned kindOffset = index * 2;
+    unsigned constraintOffset = index * 2 + 1;
+
+    // If we have already put this kind into the map, we require the constraint
+    // offset to be the same, i.e. we only allow for a kind to be added twice if
+    // the constraint is idempotent. We assert otherwise.
+    assert((!data[kindOffset] || UseLifetimeConstraint(bool(
+                                     data[constraintOffset])) == constraint) &&
+           "Adding kind twice to the map with different constraints?!");
+    data[kindOffset] = true;
+    data[constraintOffset] = bool(constraint);
+  }
+
+  void addCompatibilityConstraint(ValueOwnershipKind kind,
+                                  UseLifetimeConstraint constraint) {
+    add(ValueOwnershipKind::Any, UseLifetimeConstraint::MustBeLive);
+    add(kind, constraint);
+  }
+
+  bool canAcceptKind(ValueOwnershipKind kind) const {
+    unsigned index = unsigned(kind);
+    unsigned kindOffset = index * 2;
+    return data[kindOffset];
+  }
+
+  UseLifetimeConstraint getLifetimeConstraint(ValueOwnershipKind kind) const;
+
+  void print(llvm::raw_ostream &os) const;
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const, "only for use in a debugger");
+};
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     OperandOwnershipKindMap map) {
+  map.print(os);
+  return os;
+}
+
+// Out of line to work around lack of forward declaration for operator <<.
+inline UseLifetimeConstraint
+OperandOwnershipKindMap::getLifetimeConstraint(ValueOwnershipKind kind) const {
+#ifndef NDEBUG
+  if (!canAcceptKind(kind)) {
+    llvm::errs() << "Can not lookup lifetime constraint: " << kind
+                 << ". Not in map!\n"
+                 << *this;
+    llvm_unreachable("standard error assertion");
+  }
+#endif
+  unsigned constraintOffset = unsigned(kind) * 2 + 1;
+  return UseLifetimeConstraint(data[constraintOffset]);
+}
+
 /// A formal SIL reference to a value, suitable for use as a stored
 /// operand.
 class Operand {
@@ -413,10 +595,20 @@ class Operand {
   SILInstruction *getUser() { return Owner; }
   const SILInstruction *getUser() const { return Owner; }
 
-  /// getOperandNumber - Return which operand this is in the operand list of the
-  /// using instruction.
+  /// Return which operand this is in the operand list of the using instruction.
   unsigned getOperandNumber() const;
 
+  /// Return the static map of ValueOwnershipKinds that this operand can
+  /// potentially have to the UseLifetimeConstraint associated with that
+  /// ownership kind
+  ///
+  /// NOTE: This is implemented in OperandOwnershipKindMapClassifier.cpp.
+  ///
+  /// NOTE: The default argument isSubValue is a temporary staging flag that
+  /// will be removed once borrow scoping is checked by the normal verifier.
+  OperandOwnershipKindMap
+  getOwnershipKindMap(bool isForwardingSubValue = false) const;
+
 private:
   void removeFromCurrent() {
     if (!Back) return;

include/swift/SILOptimizer/Utils/Local.h

@@ -246,8 +246,8 @@ class ValueLifetimeAnalysis {
   /// In this case, if \p mode is AllowToModifyCFG, those critical edges are
   /// split, otherwise nothing is done and the returned \p Fr is not valid.
   ///
-  /// If \p DEBlocks is provided, all dead-end blocks are ignored. This prevents
-  /// unreachable-blocks to be included in the frontier.
+  /// If \p deadEndBlocks is provided, all dead-end blocks are ignored. This
+  /// prevents unreachable-blocks to be included in the frontier.
   bool computeFrontier(Frontier &Fr, Mode mode,
                        DeadEndBlocks *DEBlocks = nullptr);