Merge pull request swiftlang#35152 from atrick/ownershipenum

Convert OperandOwnership from an enum class to a struct enum.

Author: atrick

include/swift/SIL/SILValue.h

@@ -226,7 +226,7 @@ struct OwnershipKind {
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const OwnershipKind &kind);
 
-enum class OperandOwnership;
+struct OperandOwnership;
 
 /// A value representing the specific ownership semantics that a SILValue may
 /// have.
@@ -624,86 +624,108 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
 /// Used to verify completeness of the ownership use model and exhaustively
 /// switch over any category of ownership use. Implies ownership constraints and
 /// lifetime constraints.
-enum class OperandOwnership {
-  /// Uses of ownership None. These uses are incompatible with values that have
-  /// ownership but are otherwise not verified.
-  None,
-
-  /// Use the value only for the duration of the operation, which may have side
-  /// effects. Requires an owned or guaranteed value.
-  /// (single-instruction apply with @guaranteed argument)
-  InstantaneousUse,
-
-  /// MARK: Uses of Any ownership values:
-
-  /// Use a value without requiring or propagating ownership. The operation may
-  /// not have side-effects that could affect ownership. This is limited to a
-  /// small number of operations that are allowed to take Unowned values.
-  /// (copy_value, single-instruction apply with @unowned argument))
-  UnownedInstantaneousUse,
-
-  /// Forwarding instruction with an Unowned result. Its operands may have any
-  /// ownership.
-  ForwardingUnowned,
-
-  // Escape a pointer into a value in a way that cannot be tracked or verified.
-  //
-  // TODO: Eliminate the PointerEscape category. All pointer escapes should be
-  // InteriorPointer, guarded by a borrow scope, and verified.
-  PointerEscape,
-
-  /// Bitwise escape. Escapes the nontrivial contents of the value.
-  /// OSSA does not enforce the lifetime of the escaping bits.
-  /// The programmer must explicitly force lifetime extension.
-  /// (ref_to_unowned, unchecked_trivial_bitcast)
-  BitwiseEscape,
-
-  /// MARK: Uses of Owned values:
-
-  /// Borrow. Propagates the owned value within a scope, without consuming it.
-  /// (begin_borrow, begin_apply with @guaranteed argument)
-  Borrow,
-  /// Destroying Consume. Destroys the owned value immediately.
-  /// (store, destroy, @owned destructure).
-  DestroyingConsume,
-  /// Forwarding Consume. Consumes the owned value indirectly via a move.
-  /// (br, destructure, tuple, struct, cast, switch).
-  ForwardingConsume,
-
-  /// MARK: Uses of Guaranteed values:
-
-  /// Nested Borrow. Propagates the guaranteed value within a nested borrow
-  /// scope, without ending the outer borrow scope, following stack discipline.
-  /// (begin_borrow, begin_apply with @guaranteed).
-  NestedBorrow,
-  /// Interior Pointer. Propagates a trivial value (e.g. address, pointer, or
-  /// no-escape closure) that depends on the guaranteed value within the base's
-  /// borrow scope. The verifier checks that all uses of the trivial value are
-  /// in scope.  (ref_element_addr, open_existential_box)
-  InteriorPointer,
-  /// Forwarded Borrow. Propagates the guaranteed value within the base's
-  /// borrow scope.
-  /// (tuple_extract, struct_extract, cast, switch)
-  ForwardingBorrow,
-  /// End Borrow. End the borrow scope opened directly by the operand.
-  /// The operand must be a begin_borrow, begin_apply, or function argument.
-  /// (end_borrow, end_apply)
-  EndBorrow,
-  // Reborrow. Ends the borrow scope opened directly by the operand and begins
-  // one or multiple disjoint borrow scopes. If a forwarded value is reborrowed,
-  // then its base must also be reborrowed at the same point.
-  // (br, FIXME: should also include destructure, tuple, struct)
-  Reborrow
+struct OperandOwnership {
+  enum innerty : uint8_t {
+    /// Uses of ownership None. These uses are incompatible with values that
+    /// have ownership but are otherwise not verified.
+    None,
+
+    /// Use the value only for the duration of the operation, which may have
+    /// side effects. Requires an owned or guaranteed value.
+    /// (single-instruction apply with @guaranteed argument)
+    InstantaneousUse,
+
+    /// MARK: Uses of Any ownership values:
+
+    /// Use a value without requiring or propagating ownership. The operation
+    /// may not have side-effects that could affect ownership. This is limited
+    /// to a small number of operations that are allowed to take Unowned values.
+    /// (copy_value, single-instruction apply with @unowned argument))
+    UnownedInstantaneousUse,
+
+    /// Forwarding instruction with an Unowned result. Its operands may have any
+    /// ownership.
+    ForwardingUnowned,
+
+    // Escape a pointer into a value which cannot be tracked or verified.
+    //
+    // TODO: Eliminate the PointerEscape category. All pointer escapes should be
+    // InteriorPointer, guarded by a borrow scope, and verified.
+    PointerEscape,
+
+    /// Bitwise escape. Escapes the nontrivial contents of the value.
+    /// OSSA does not enforce the lifetime of the escaping bits.
+    /// The programmer must explicitly force lifetime extension.
+    /// (ref_to_unowned, unchecked_trivial_bitcast)
+    BitwiseEscape,
+
+    /// MARK: Uses of Owned values:
+
+    /// Borrow. Propagates the owned value within a scope, without consuming it.
+    /// (begin_borrow, begin_apply with @guaranteed argument)
+    Borrow,
+    /// Destroying Consume. Destroys the owned value immediately.
+    /// (store, destroy, @owned destructure).
+    DestroyingConsume,
+    /// Forwarding Consume. Consumes the owned value indirectly via a move.
+    /// (br, destructure, tuple, struct, cast, switch).
+    ForwardingConsume,
+
+    /// MARK: Uses of Guaranteed values:
+
+    /// Nested Borrow. Propagates the guaranteed value within a nested borrow
+    /// scope, without ending the outer borrow scope, following stack
+    /// discipline.
+    /// (begin_borrow, begin_apply with @guaranteed).
+    NestedBorrow,
+    /// Interior Pointer. Propagates a trivial value (e.g. address, pointer, or
+    /// no-escape closure) that depends on the guaranteed value within the
+    /// base's borrow scope. The verifier checks that all uses of the trivial
+    /// value are in scope.
+    /// (ref_element_addr, open_existential_box)
+    InteriorPointer,
+    /// Forwarded Borrow. Propagates the guaranteed value within the base's
+    /// borrow scope.
+    /// (tuple_extract, struct_extract, cast, switch)
+    ForwardingBorrow,
+    /// End Borrow. End the borrow scope opened directly by the operand.
+    /// The operand must be a begin_borrow, begin_apply, or function argument.
+    /// (end_borrow, end_apply)
+    EndBorrow,
+    // Reborrow. Ends the borrow scope opened directly by the operand and begins
+    // one or multiple disjoint borrow scopes. If a forwarded value is
+    // reborrowed, then its base must also be reborrowed at the same point.
+    // (br, FIXME: should also include destructure, tuple, struct)
+    Reborrow
+  } value;
+
+  OperandOwnership(innerty newValue) : value(newValue) {}
+  OperandOwnership(const OperandOwnership &other): value(other.value) {}
+
+  OperandOwnership &operator=(const OperandOwnership &other) {
+    value = other.value;
+    return *this;
+  }
+
+  OperandOwnership &operator=(OperandOwnership::innerty other) {
+    value = other;
+    return *this;
+  }
+
+  operator innerty() const { return value; }
+
+  StringRef asString() const;
+
+  /// Return the OwnershipConstraint corresponding to this OperandOwnership.
+  OwnershipConstraint getOwnershipConstraint();
 };
 
-llvm::raw_ostream &operator<<(llvm::raw_ostream &os, OperandOwnership operandOwnership);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              const OperandOwnership &operandOwnership);
 
-/// Return the OwnershipConstraint for a OperandOwnership.
-///
 /// Defined inline so the switch is eliminated for constant OperandOwnership.
-inline OwnershipConstraint
-getOwnershipConstraint(OperandOwnership operandOwnership) {
-  switch (operandOwnership) {
+inline OwnershipConstraint OperandOwnership::getOwnershipConstraint() {
+  switch (value) {
   case OperandOwnership::None:
     return {OwnershipKind::None, UseLifetimeConstraint::NonLifetimeEnding};
   case OperandOwnership::InstantaneousUse:
@@ -847,7 +869,7 @@ class Operand {
     if (!operandOwnership) {
       return None;
     }
-    return swift::getOwnershipConstraint(operandOwnership.getValue());
+    return operandOwnership->getOwnershipConstraint();
   }
 
   /// Returns true if changing the operand to use a value with the given

lib/SIL/IR/OperandOwnership.cpp

@@ -791,7 +791,7 @@ Optional<OperandOwnership> Operand::getOperandOwnership() const {
     // If we don't have a function, then we must have a SILGlobalVariable. In
     // that case, we act as if we aren't in ownership.
     if (!func || !func->hasOwnership()) {
-      return OperandOwnership::InstantaneousUse;
+      return OperandOwnership(OperandOwnership::InstantaneousUse);
     }
   }
 

lib/SIL/IR/SILValue.cpp

@@ -346,7 +346,7 @@ bool Operand::canAcceptKind(ValueOwnershipKind kind) const {
   if (!operandOwnership) {
     return false;
   }
-  auto constraint = ::getOwnershipConstraint(operandOwnership.getValue());
+  auto constraint = operandOwnership->getOwnershipConstraint();
   if (constraint.satisfiesConstraint(kind)) {
     // Constraints aren't precise enough to enforce Unowned value uses.
     if (kind == OwnershipKind::Unowned) {
@@ -397,51 +397,40 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
             << ">";
 }
 
-llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
-                                     OperandOwnership operandOwnership) {
-  switch (operandOwnership) {
+StringRef OperandOwnership::asString() const {
+  switch (value) {
   case OperandOwnership::None:
-    os << "none";
-    break;
+    return "none";
   case OperandOwnership::InstantaneousUse:
-    os << "instantaneous";
-    break;
+    return "instantaneous";
   case OperandOwnership::UnownedInstantaneousUse:
-    os << "unowned-instantaneous";
-    break;
+    return "unowned-instantaneous";
   case OperandOwnership::ForwardingUnowned:
-    os << "forwarding-unowned";
-    break;
+    return "forwarding-unowned";
   case OperandOwnership::PointerEscape:
-    os << "pointer-escape";
-    break;
+    return "pointer-escape";
   case OperandOwnership::BitwiseEscape:
-    os << "bitwise-escape";
-    break;
+    return "bitwise-escape";
   case OperandOwnership::Borrow:
-    os << "borrow";
-    break;
+    return "borrow";
   case OperandOwnership::DestroyingConsume:
-    os << "destroying-consume";
-    break;
+    return "destroying-consume";
   case OperandOwnership::ForwardingConsume:
-    os << "forwarding-consume";
-    break;
+    return "forwarding-consume";
   case OperandOwnership::NestedBorrow:
-    os << "nested-borrow";
-    break;
+    return "nested-borrow";
   case OperandOwnership::InteriorPointer:
-    os << "interior-pointer";
-    break;
+    return "interior-pointer";
   case OperandOwnership::ForwardingBorrow:
-    os << "forwarding-borrow";
-    break;
+    return "forwarding-borrow";
   case OperandOwnership::EndBorrow:
-    os << "end-borrow";
-    break;
+    return "end-borrow";
   case OperandOwnership::Reborrow:
-    os << "reborrow";
-    break;
+    return "reborrow";
   }
-  return os;
+}
+
+llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &os,
+                                     const OperandOwnership &operandOwnership) {
+  return os << operandOwnership.asString();
 }

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -326,7 +326,8 @@ bool SILValueOwnershipChecker::gatherUsers(
     // Example: A guaranteed parameter of a co-routine.
 
     // Now check if we have a non guaranteed forwarding inst...
-    if (op->getOperandOwnership() != OperandOwnership::ForwardingBorrow) {
+    if (op->getOperandOwnership().getValue()
+        != OperandOwnership::ForwardingBorrow) {
       // First check if we are visiting an operand that is a consuming use...
       if (op->isLifetimeEnding()) {
         // If its underlying value is our original value, then this is a true