Merge pull request #19445 from gottesmm/ownership-kind-set-classifer

[ownership] Extract out from SILOwnershipVerifier the OperandOwnershi…

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/SILModule.h

@@ -378,6 +378,8 @@ class SILModule {
     return wholeModule;
   }
 
+  bool isStdlibModule() const;
+
   /// Returns true if it is the optimized OnoneSupport module.
   bool isOptimizedOnoneSupportModule() const;
 

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);
 

lib/SIL/SILModule.cpp

@@ -660,6 +660,10 @@ void SILModule::setOptRecordStream(
   OptRecordRawStream = std::move(RawStream);
 }
 
+bool SILModule::isStdlibModule() const {
+  return TheSwiftModule->isStdlibModule();
+}
+
 SILProperty *SILProperty::create(SILModule &M,
                                  bool Serialized,
                                  AbstractStorageDecl *Decl,