Merge pull request swiftlang#34634 from gottesmm/pr-88f0c52a3c1db5fb272598e5c5596ce3594d804c

[ownership] Make checked_cast_br, destructure_struct, and destructure_tuple real forwarding instructions

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -66,6 +66,20 @@ bool isOwnedForwardingInstruction(SILInstruction *inst);
 /// previous terminator.
 bool isOwnedForwardingValue(SILValue value);
 
+class ForwardingOperand {
+  Operand *use;
+
+  ForwardingOperand(Operand *use) : use(use) {}
+
+public:
+  static Optional<ForwardingOperand> get(Operand *use);
+
+  ValueOwnershipKind getOwnershipKind() const;
+  void setOwnershipKind(ValueOwnershipKind newKind) const;
+  void replaceOwnershipKind(ValueOwnershipKind oldKind,
+                            ValueOwnershipKind newKind) const;
+};
+
 /// Returns true if the instruction is a 'reborrow'.
 bool isReborrowInstruction(const SILInstruction *inst);
 

include/swift/SIL/SILInstruction.h

@@ -1095,6 +1095,12 @@ class MultipleValueInstructionTrailingObjects<Derived, DerivedResult,
     return { ptr, NumResults };
   }
 
+  MutableArrayRef<DerivedResult> getAllResultsBuffer() {
+    auto *ptr = this->TrailingObjects::template
+        getTrailingObjects<DerivedResult>();
+    return { ptr, NumResults };
+  }
+
   SILInstructionResultArray getAllResults() const {
     // Our results start at element 1 since we stash the pointer to our parent
     // MultipleValueInstruction in the 0 elt slot. This allows all
@@ -8126,23 +8132,20 @@ class DynamicMethodBranchInst
 };
 
 /// The base class for cast instructions which are terminators.
-class CastBranchInstBase : public TermInst {
+template <typename BaseTy> class CastBranchInstBase : public BaseTy {
   std::array<SILSuccessor, 2> DestBBs;
 
 public:
-
+  template <typename... ArgTys>
   CastBranchInstBase(SILInstructionKind K, SILDebugLocation DebugLoc,
                      SILBasicBlock *SuccessBB, SILBasicBlock *FailureBB,
-                     ProfileCounter Target1Count = ProfileCounter(),
-                     ProfileCounter Target2Count = ProfileCounter()) :
-    TermInst(K, DebugLoc),
-    DestBBs{{{this, SuccessBB, Target1Count},
-             {this, FailureBB, Target2Count}}}
-      {}
+                     ProfileCounter Target1Count, ProfileCounter Target2Count,
+                     ArgTys &&... args)
+      : BaseTy(K, DebugLoc, std::forward<ArgTys>(args)...),
+        DestBBs{{{this, SuccessBB, Target1Count},
+                 {this, FailureBB, Target2Count}}} {}
 
-  SuccessorListTy getSuccessors() {
-    return DestBBs;
-  }
+  TermInst::SuccessorListTy getSuccessors() { return DestBBs; }
 
   SILBasicBlock *getSuccessBB() { return DestBBs[0]; }
   const SILBasicBlock *getSuccessBB() const { return DestBBs[0]; }
@@ -8157,7 +8160,7 @@ class CastBranchInstBase : public TermInst {
 
 /// The base class for cast instructions which are terminators and have a
 /// CastConsumptionKind.
-class CastBranchWithConsumptionKindBase : public CastBranchInstBase {
+class CastBranchWithConsumptionKindBase : public CastBranchInstBase<TermInst> {
   CastConsumptionKind ConsumptionKind;
 
 public:
@@ -8250,11 +8253,10 @@ class AddrCastInstBase
 /// Perform a checked cast operation and branch on whether the cast succeeds.
 /// The success branch destination block receives the cast result as a BB
 /// argument.
-class CheckedCastBranchInst final:
-  public UnaryInstructionWithTypeDependentOperandsBase<
-                              SILInstructionKind::CheckedCastBranchInst,
-                              CheckedCastBranchInst,
-                              CastBranchInstBase> {
+class CheckedCastBranchInst final
+    : public UnaryInstructionWithTypeDependentOperandsBase<
+          SILInstructionKind::CheckedCastBranchInst, CheckedCastBranchInst,
+          CastBranchInstBase<OwnershipForwardingTermInst>> {
   friend SILBuilder;
 
   SILType DestLoweredTy;
@@ -8266,12 +8268,12 @@ class CheckedCastBranchInst final:
                         ArrayRef<SILValue> TypeDependentOperands,
                         SILType DestLoweredTy, CanType DestFormalTy,
                         SILBasicBlock *SuccessBB, SILBasicBlock *FailureBB,
-                        ProfileCounter Target1Count, ProfileCounter Target2Count)
-      : UnaryInstructionWithTypeDependentOperandsBase(DebugLoc, Operand,
-            TypeDependentOperands,
-            SuccessBB, FailureBB, Target1Count, Target2Count),
-        DestLoweredTy(DestLoweredTy),
-        DestFormalTy(DestFormalTy),
+                        ProfileCounter Target1Count,
+                        ProfileCounter Target2Count)
+      : UnaryInstructionWithTypeDependentOperandsBase(
+            DebugLoc, Operand, TypeDependentOperands, SuccessBB, FailureBB,
+            Target1Count, Target2Count, Operand.getOwnershipKind()),
+        DestLoweredTy(DestLoweredTy), DestFormalTy(DestFormalTy),
         IsExact(IsExact) {}
 
   static CheckedCastBranchInst *
@@ -8297,23 +8299,23 @@ class CheckedCastBranchInst final:
 class CheckedCastValueBranchInst final
     : public UnaryInstructionWithTypeDependentOperandsBase<
           SILInstructionKind::CheckedCastValueBranchInst,
-          CheckedCastValueBranchInst,
-          CastBranchInstBase> {
+          CheckedCastValueBranchInst, CastBranchInstBase<TermInst>> {
   friend SILBuilder;
 
   CanType SourceFormalTy;
   SILType DestLoweredTy;
   CanType DestFormalTy;
 
-  CheckedCastValueBranchInst(SILDebugLocation DebugLoc,
-                             SILValue Operand, CanType SourceFormalTy,
+  CheckedCastValueBranchInst(SILDebugLocation DebugLoc, SILValue Operand,
+                             CanType SourceFormalTy,
                              ArrayRef<SILValue> TypeDependentOperands,
                              SILType DestLoweredTy, CanType DestFormalTy,
                              SILBasicBlock *SuccessBB, SILBasicBlock *FailureBB)
-      : UnaryInstructionWithTypeDependentOperandsBase(DebugLoc, Operand,
-                                  TypeDependentOperands, SuccessBB, FailureBB),
-        SourceFormalTy(SourceFormalTy),
-        DestLoweredTy(DestLoweredTy), DestFormalTy(DestFormalTy) {}
+      : UnaryInstructionWithTypeDependentOperandsBase(
+            DebugLoc, Operand, TypeDependentOperands, SuccessBB, FailureBB,
+            ProfileCounter(), ProfileCounter()),
+        SourceFormalTy(SourceFormalTy), DestLoweredTy(DestLoweredTy),
+        DestFormalTy(DestFormalTy) {}
 
   static CheckedCastValueBranchInst *
   create(SILDebugLocation DebugLoc,
@@ -8757,6 +8759,23 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
   }
 }
 
+class OwnershipForwardingMultipleValueInstruction
+    : public MultipleValueInstruction {
+  ValueOwnershipKind ownershipKind;
+
+public:
+  OwnershipForwardingMultipleValueInstruction(SILInstructionKind kind,
+                                              SILDebugLocation loc,
+                                              ValueOwnershipKind ownershipKind)
+      : MultipleValueInstruction(kind, loc), ownershipKind(ownershipKind) {}
+
+  /// Returns the preferred ownership kind of this multiple value instruction.
+  ValueOwnershipKind getOwnershipKind() const { return ownershipKind; }
+  void setOwnershipKind(ValueOwnershipKind newOwnershipKind) {
+    ownershipKind = newOwnershipKind;
+  }
+};
+
 /// A result for the destructure_struct instruction. See documentation for
 /// destructure_struct for more information.
 class DestructureStructResult final : public MultipleValueInstructionResult {
@@ -8780,15 +8799,15 @@ class DestructureStructResult final : public MultipleValueInstructionResult {
 /// struct's fields.
 class DestructureStructInst final
     : public UnaryInstructionBase<SILInstructionKind::DestructureStructInst,
-                                  MultipleValueInstruction>,
-      public MultipleValueInstructionTrailingObjects<
-          DestructureStructInst, DestructureStructResult> {
+                                  OwnershipForwardingMultipleValueInstruction>,
+      public MultipleValueInstructionTrailingObjects<DestructureStructInst,
+                                                     DestructureStructResult> {
   friend TrailingObjects;
 
   DestructureStructInst(SILModule &M, SILDebugLocation Loc, SILValue Operand,
                         ArrayRef<SILType> Types,
                         ArrayRef<ValueOwnershipKind> OwnershipKinds)
-      : UnaryInstructionBase(Loc, Operand),
+      : UnaryInstructionBase(Loc, Operand, Operand.getOwnershipKind()),
         MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
 
 public:
@@ -8829,15 +8848,15 @@ class DestructureTupleResult final : public MultipleValueInstructionResult {
 /// tuples's elements.
 class DestructureTupleInst final
     : public UnaryInstructionBase<SILInstructionKind::DestructureTupleInst,
-                                  MultipleValueInstruction>,
-      public MultipleValueInstructionTrailingObjects<
-          DestructureTupleInst, DestructureTupleResult> {
+                                  OwnershipForwardingMultipleValueInstruction>,
+      public MultipleValueInstructionTrailingObjects<DestructureTupleInst,
+                                                     DestructureTupleResult> {
   friend TrailingObjects;
 
   DestructureTupleInst(SILModule &M, SILDebugLocation Loc, SILValue Operand,
                        ArrayRef<SILType> Types,
                        ArrayRef<ValueOwnershipKind> OwnershipKinds)
-      : UnaryInstructionBase(Loc, Operand),
+      : UnaryInstructionBase(Loc, Operand, Operand.getOwnershipKind()),
         MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
 
 public:

lib/SIL/IR/OperandOwnership.cpp

@@ -73,12 +73,6 @@ class OperandOwnershipKindClassifier
     return getOwnershipKind() == ValueOwnershipKind::None;
   }
 
-  OperandOwnershipKindMap visitForwardingInst(SILInstruction *i,
-                                              ArrayRef<Operand> ops);
-  OperandOwnershipKindMap visitForwardingInst(SILInstruction *i) {
-    return visitForwardingInst(i, i->getAllOperands());
-  }
-
   OperandOwnershipKindMap
   visitApplyParameter(ValueOwnershipKind requiredConvention,
                       UseLifetimeConstraint requirement);
@@ -299,38 +293,12 @@ ACCEPTS_ANY_OWNERSHIP_INST(ConvertEscapeToNoEscape)
 #include "swift/AST/ReferenceStorage.def"
 #undef ACCEPTS_ANY_OWNERSHIP_INST
 
-OperandOwnershipKindMap
-OperandOwnershipKindClassifier::visitForwardingInst(SILInstruction *i,
-                                                    ArrayRef<Operand> ops) {
-  assert(i->getNumOperands() && "Expected to have non-zero operands");
-  assert(isOwnershipForwardingInst(i) &&
-         "Expected to have an ownership forwarding inst");
-
-  // Merge all of the ownership of our operands. If we get back a .none from the
-  // merge, then we return an empty compatibility map. This ensures that we will
-  // not be compatible with /any/ input triggering a special error in the
-  // ownership verifier.
-  Optional<ValueOwnershipKind> optionalKind =
-      ValueOwnershipKind::merge(makeOptionalTransformRange(
-          ops, [&i](const Operand &op) -> Optional<ValueOwnershipKind> {
-            if (i->isTypeDependentOperand(op))
-              return None;
-            return op.get().getOwnershipKind();
-          }));
-  if (!optionalKind)
-    return Map();
-
-  auto kind = optionalKind.getValue();
-  if (kind == ValueOwnershipKind::None)
-    return Map::allLive();
-  auto lifetimeConstraint = kind.getForwardingLifetimeConstraint();
-  return Map::compatibilityMap(kind, lifetimeConstraint);
-}
-
 #define FORWARD_ANY_OWNERSHIP_INST(INST)                                       \
   OperandOwnershipKindMap OperandOwnershipKindClassifier::visit##INST##Inst(   \
       INST##Inst *i) {                                                         \
-    return visitForwardingInst(i);                                             \
+    auto kind = i->getOwnershipKind();                                         \
+    auto lifetimeConstraint = kind.getForwardingLifetimeConstraint();          \
+    return Map::compatibilityMap(kind, lifetimeConstraint);                    \
   }
 FORWARD_ANY_OWNERSHIP_INST(Tuple)
 FORWARD_ANY_OWNERSHIP_INST(Struct)
@@ -344,12 +312,12 @@ FORWARD_ANY_OWNERSHIP_INST(RefToBridgeObject)
 FORWARD_ANY_OWNERSHIP_INST(BridgeObjectToRef)
 FORWARD_ANY_OWNERSHIP_INST(UnconditionalCheckedCast)
 FORWARD_ANY_OWNERSHIP_INST(UncheckedEnumData)
-FORWARD_ANY_OWNERSHIP_INST(DestructureStruct)
-FORWARD_ANY_OWNERSHIP_INST(DestructureTuple)
 FORWARD_ANY_OWNERSHIP_INST(InitExistentialRef)
 FORWARD_ANY_OWNERSHIP_INST(DifferentiableFunction)
 FORWARD_ANY_OWNERSHIP_INST(LinearFunction)
 FORWARD_ANY_OWNERSHIP_INST(UncheckedValueCast)
+FORWARD_ANY_OWNERSHIP_INST(DestructureStruct)
+FORWARD_ANY_OWNERSHIP_INST(DestructureTuple)
 #undef FORWARD_ANY_OWNERSHIP_INST
 
 // An instruction that forwards a constant ownership or trivial ownership.
@@ -395,7 +363,9 @@ OperandOwnershipKindClassifier::visitSelectEnumInst(SelectEnumInst *i) {
     return Map::allLive();
   }
 
-  return visitForwardingInst(i, i->getAllOperands().drop_front());
+  auto kind = i->getOwnershipKind();
+  auto lifetimeConstraint = kind.getForwardingLifetimeConstraint();
+  return Map::compatibilityMap(kind, lifetimeConstraint);
 }
 
 OperandOwnershipKindMap
@@ -458,31 +428,9 @@ OperandOwnershipKindClassifier::visitSwitchEnumInst(SwitchEnumInst *sei) {
 OperandOwnershipKindMap
 OperandOwnershipKindClassifier::visitCheckedCastBranchInst(
     CheckedCastBranchInst *ccbi) {
-  // TODO: Simplify this using ValueOwnershipKind::merge.
-  Optional<OperandOwnershipKindMap> map;
-  for (auto argArray : ccbi->getSuccessorBlockArgumentLists()) {
-    assert(!argArray.empty());
-
-    auto argOwnershipKind = argArray[getOperandIndex()]->getOwnershipKind();
-    // If we do not have a map yet, initialize it and continue.
-    if (!map) {
-      auto lifetimeConstraint =
-          argOwnershipKind.getForwardingLifetimeConstraint();
-      map = Map::compatibilityMap(argOwnershipKind, lifetimeConstraint);
-      continue;
-    }
-
-    // Otherwise, make sure that we can accept the rest of our
-    // arguments. If not, we return an empty ownership kind to make
-    // sure that we flag everything as an error.
-    if (map->canAcceptKind(argOwnershipKind)) {
-      continue;
-    }
-
-    return OperandOwnershipKindMap();
-  }
-
-  return map.getValue();
+  auto kind = getOwnershipKind();
+  auto lifetimeConstraint = kind.getForwardingLifetimeConstraint();
+  return Map::compatibilityMap(kind, lifetimeConstraint);
 }
 
 //// FIX THIS HERE