Merge pull request swiftlang#35297 from gottesmm/ossa-sil-combine-2

[sil-combine] Fix for Ownership round 2

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -82,29 +82,24 @@ class ForwardingOperand {
 public:
   static Optional<ForwardingOperand> get(Operand *use);
 
-  Operand *getUse() const { return use; }
   OwnershipConstraint getOwnershipConstraint() const {
     // We use a force unwrap since a ForwardingOperand should always have an
     // ownership constraint.
     return use->getOwnershipConstraint();
   }
+
   ValueOwnershipKind getOwnershipKind() const;
   void setOwnershipKind(ValueOwnershipKind newKind) const;
   void replaceOwnershipKind(ValueOwnershipKind oldKind,
                             ValueOwnershipKind newKind) const;
 
-  const OwnershipForwardingInst *operator->() const {
-    return cast<OwnershipForwardingInst>(use->getUser());
-  }
-  OwnershipForwardingInst *operator->() {
-    return cast<OwnershipForwardingInst>(use->getUser());
-  }
-  const OwnershipForwardingInst &operator*() const {
-    return *cast<OwnershipForwardingInst>(use->getUser());
-  }
-  OwnershipForwardingInst &operator*() {
-    return *cast<OwnershipForwardingInst>(use->getUser());
-  }
+  const Operand *operator->() const { return use; }
+
+  Operand *operator->() { return use; }
+
+  const Operand &operator*() const { return *use; }
+
+  Operand &operator*() { return *use; }
 
   /// Call \p visitor with each value that contains the final forwarded
   /// ownership of. E.x.: result of a unchecked_ref_cast, phi arguments of a
@@ -473,6 +468,13 @@ struct BorrowedValue {
     return foundAnyReborrows;
   }
 
+  // Helpers to allow a BorrowedValue to easily be used as a SILValue
+  // programatically.
+  SILValue operator->() { return value; }
+  SILValue operator->() const { return value; }
+  SILValue operator*() { return value; }
+  SILValue operator*() const { return value; }
+
 private:
   /// Internal constructor for failable static constructor. Please do not expand
   /// its usage since it assumes the code passed in is well formed.
@@ -505,6 +507,7 @@ Optional<BorrowedValue> getSingleBorrowIntroducingValue(SILValue inputValue);
 class InteriorPointerOperandKind {
 public:
   enum Kind : uint8_t {
+    Invalid=0,
     RefElementAddr,
     RefTailAddr,
     OpenExistentialBox,
@@ -516,18 +519,38 @@ class InteriorPointerOperandKind {
 public:
   InteriorPointerOperandKind(Kind newValue) : value(newValue) {}
 
-  operator Kind() const { return value; }
+  operator Kind() const {
+    return value;
+  }
+
+  bool isValid() const { return value != Kind::Invalid; }
 
-  static Optional<InteriorPointerOperandKind> get(Operand *use) {
+  static InteriorPointerOperandKind get(Operand *use) {
     switch (use->getUser()->getKind()) {
     default:
-      return None;
+      return Kind::Invalid;
     case SILInstructionKind::RefElementAddrInst:
-      return InteriorPointerOperandKind(RefElementAddr);
+      return Kind::RefElementAddr;
     case SILInstructionKind::RefTailAddrInst:
-      return InteriorPointerOperandKind(RefTailAddr);
+      return Kind::RefTailAddr;
     case SILInstructionKind::OpenExistentialBoxInst:
-      return InteriorPointerOperandKind(OpenExistentialBox);
+      return Kind::OpenExistentialBox;
+    }
+  }
+
+  /// Given a \p value that is a result of an instruction with an interior
+  /// pointer operand, return the interior pointer operand kind that would be
+  /// appropriate for that operand.
+  static InteriorPointerOperandKind inferFromResult(SILValue value) {
+    switch (value->getKind()) {
+    default:
+      return Kind::Invalid;
+    case ValueKind::RefElementAddrInst:
+      return Kind::RefElementAddr;
+    case ValueKind::RefTailAddrInst:
+      return Kind::RefTailAddr;
+    case ValueKind::OpenExistentialBoxInst:
+      return Kind::OpenExistentialBox;
     }
   }
 
@@ -544,14 +567,42 @@ struct InteriorPointerOperand {
   InteriorPointerOperandKind kind;
 
   InteriorPointerOperand(Operand *op)
-      : operand(op), kind(*InteriorPointerOperandKind::get(op)) {}
+      : operand(op), kind(InteriorPointerOperandKind::get(op)) {
+    assert(kind.isValid());
+  }
 
-  /// If value is a borrow introducer return it after doing some checks.
+  /// If \p op has a user that is an interior pointer, return a valid
+  /// value. Otherwise, return None.
   static Optional<InteriorPointerOperand> get(Operand *op) {
     auto kind = InteriorPointerOperandKind::get(op);
     if (!kind)
       return None;
-    return InteriorPointerOperand(op, *kind);
+    return InteriorPointerOperand(op, kind);
+  }
+
+  /// If \p val is a result of an instruction that is an interior pointer,
+  /// return an interor pointer operand based off of the base value operand of
+  /// the instruction.
+  static Optional<InteriorPointerOperand>
+  inferFromResult(SILValue resultValue) {
+    auto kind = InteriorPointerOperandKind::inferFromResult(resultValue);
+
+    // NOTE: We use an exhaustive switch here to allow for further interior
+    // pointer operand having instructions to make the interior pointer
+    // operand's argument index arbitrary.
+    switch (kind) {
+    case InteriorPointerOperandKind::Invalid:
+      // We do not have a valid instruction, so return None.
+      return None;
+    case InteriorPointerOperandKind::RefElementAddr:
+    case InteriorPointerOperandKind::RefTailAddr:
+    case InteriorPointerOperandKind::OpenExistentialBox: {
+      // Ok, we have a valid instruction. Return the relevant operand.
+      auto *op =
+          &cast<SingleValueInstruction>(resultValue)->getAllOperands()[0];
+      return InteriorPointerOperand(op, kind);
+    }
+    }
   }
 
   /// Return the end scope of all borrow introducers of the parent value of this
@@ -569,8 +620,15 @@ struct InteriorPointerOperand {
     return true;
   }
 
+  /// Return the base BorrowedValue of the incoming value's operand.
+  Optional<BorrowedValue> getSingleBaseValue() const {
+    return getSingleBorrowIntroducingValue(operand->get());
+  }
+
   SILValue getProjectedAddress() const {
     switch (kind) {
+    case InteriorPointerOperandKind::Invalid:
+      llvm_unreachable("Calling method on invalid?!");
     case InteriorPointerOperandKind::RefElementAddr:
       return cast<RefElementAddrInst>(operand->getUser());
     case InteriorPointerOperandKind::RefTailAddr:
@@ -591,6 +649,11 @@ struct InteriorPointerOperand {
   bool getImplicitUses(SmallVectorImpl<Operand *> &foundUses,
                        std::function<void(Operand *)> *onError = nullptr);
 
+  Operand *operator->() { return operand; }
+  const Operand *operator->() const { return operand; }
+  Operand *operator*() { return operand; }
+  const Operand *operator*() const { return operand; }
+
 private:
   /// Internal constructor for failable static constructor. Please do not expand
   /// its usage since it assumes the code passed in is well formed.

include/swift/SIL/SILInstruction.h

@@ -541,7 +541,19 @@ class SILInstruction
   SILValue getOperand(unsigned Num) const {
     return getAllOperands()[Num].get();
   }
-  Operand &getOperandRef(unsigned Num) { return getAllOperands()[Num]; }
+
+  /// Return the ith mutable operand of this instruction.
+  ///
+  /// Equivalent to performing getAllOperands()[index];
+  Operand &getOperandRef(unsigned index) { return getAllOperands()[index]; }
+
+  /// Return the ith operand of this instruction.
+  ///
+  /// Equivalent to performing getAllOperands()[index];
+  const Operand &getOperandRef(unsigned index) const {
+    return getAllOperands()[index];
+  }
+
   void setOperand(unsigned Num, SILValue V) { getAllOperands()[Num].set(V); }
   void swapOperands(unsigned Num1, unsigned Num2) {
     getAllOperands()[Num1].swap(getAllOperands()[Num2]);
@@ -917,32 +929,32 @@ inline SingleValueInstruction *SILNode::castToSingleValueInstruction() {
 ///
 /// NOTE: We assume that the constructor for the instruction subclass that
 /// initializes the kind field on our object is run before our constructor runs.
-class OwnershipForwardingInst {
+class OwnershipForwardingMixin {
   ValueOwnershipKind ownershipKind;
 
 protected:
-  OwnershipForwardingInst(SILInstructionKind kind,
-                          ValueOwnershipKind ownershipKind)
+  OwnershipForwardingMixin(SILInstructionKind kind,
+                           ValueOwnershipKind ownershipKind)
       : ownershipKind(ownershipKind) {
-    assert(classof(kind) && "Invalid subclass?!");
+    assert(isa(kind) && "Invalid subclass?!");
   }
 
 public:
   ValueOwnershipKind getOwnershipKind() const { return ownershipKind; }
 
   void setOwnershipKind(ValueOwnershipKind newKind) { ownershipKind = newKind; }
 
-  static bool classof(const SILNode *node) {
-    if (auto *i = dyn_cast<SILInstruction>(node))
-      return classof(i);
+  /// Defined inline below due to forward declaration issues.
+  static OwnershipForwardingMixin *get(SILInstruction *inst);
+  /// Defined inline below due to forward declaration issues.
+  static bool isa(SILInstructionKind kind);
+  static bool isa(const SILInstruction *inst) { return isa(inst->getKind()); }
+  static bool isa(const SILNode *node) {
+    node = node->getRepresentativeSILNodeInObject();
+    if (auto *i = dyn_cast<const SILInstruction>(node))
+      return isa(i);
     return false;
   }
-
-  // Defined inline below due to forward declaration issues.
-  static bool classof(const SILInstruction *inst);
-
-  /// Define inline below due to forward declaration issues.
-  static bool classof(SILInstructionKind kind);
 };
 
 /// A single value inst that forwards a static ownership from one (or all) of
@@ -952,14 +964,14 @@ class OwnershipForwardingInst {
 /// explicitly using setOwnershipKind().
 class FirstArgOwnershipForwardingSingleValueInst
     : public SingleValueInstruction,
-      public OwnershipForwardingInst {
+      public OwnershipForwardingMixin {
 protected:
   FirstArgOwnershipForwardingSingleValueInst(SILInstructionKind kind,
                                              SILDebugLocation debugLoc,
                                              SILType ty,
                                              ValueOwnershipKind ownershipKind)
       : SingleValueInstruction(kind, debugLoc, ty),
-        OwnershipForwardingInst(kind, ownershipKind) {
+        OwnershipForwardingMixin(kind, ownershipKind) {
     assert(classof(kind) && "classof missing new subclass?!");
   }
 
@@ -1084,14 +1096,14 @@ FirstArgOwnershipForwardingSingleValueInst::classof(SILInstructionKind kind) {
 
 class AllArgOwnershipForwardingSingleValueInst
     : public SingleValueInstruction,
-      public OwnershipForwardingInst {
+      public OwnershipForwardingMixin {
 protected:
   AllArgOwnershipForwardingSingleValueInst(SILInstructionKind kind,
                                            SILDebugLocation debugLoc,
                                            SILType ty,
                                            ValueOwnershipKind ownershipKind)
       : SingleValueInstruction(kind, debugLoc, ty),
-        OwnershipForwardingInst(kind, ownershipKind) {
+        OwnershipForwardingMixin(kind, ownershipKind) {
     assert(classof(kind) && "classof missing new subclass?!");
   }
 
@@ -4668,13 +4680,13 @@ class ConversionInst : public SingleValueInstruction {
 /// A conversion inst that produces a static OwnershipKind set upon the
 /// instruction's construction.
 class OwnershipForwardingConversionInst : public ConversionInst,
-                                          public OwnershipForwardingInst {
+                                          public OwnershipForwardingMixin {
 protected:
   OwnershipForwardingConversionInst(SILInstructionKind kind,
                                     SILDebugLocation debugLoc, SILType ty,
                                     ValueOwnershipKind ownershipKind)
       : ConversionInst(kind, debugLoc, ty),
-        OwnershipForwardingInst(kind, ownershipKind) {
+        OwnershipForwardingMixin(kind, ownershipKind) {
     assert(classof(kind) && "classof missing subclass?!");
   }
 
@@ -5872,15 +5884,15 @@ class SelectEnumInstBase
 
 /// A select enum inst that produces a static OwnershipKind.
 class OwnershipForwardingSelectEnumInstBase : public SelectEnumInstBase,
-                                              public OwnershipForwardingInst {
+                                              public OwnershipForwardingMixin {
 protected:
   OwnershipForwardingSelectEnumInstBase(
       SILInstructionKind kind, SILDebugLocation debugLoc, SILType type,
       bool defaultValue, Optional<ArrayRef<ProfileCounter>> caseCounts,
       ProfileCounter defaultCount, ValueOwnershipKind ownershipKind)
       : SelectEnumInstBase(kind, debugLoc, type, defaultValue, caseCounts,
                            defaultCount),
-        OwnershipForwardingInst(kind, ownershipKind) {
+        OwnershipForwardingMixin(kind, ownershipKind) {
     assert(classof(kind) && "classof missing subclass");
   }
 
@@ -7612,12 +7624,13 @@ class TermInst : public NonValueInstruction {
 };
 
 class OwnershipForwardingTermInst : public TermInst,
-                                    public OwnershipForwardingInst {
+                                    public OwnershipForwardingMixin {
 protected:
   OwnershipForwardingTermInst(SILInstructionKind kind,
                               SILDebugLocation debugLoc,
                               ValueOwnershipKind ownershipKind)
-      : TermInst(kind, debugLoc), OwnershipForwardingInst(kind, ownershipKind) {
+      : TermInst(kind, debugLoc),
+        OwnershipForwardingMixin(kind, ownershipKind) {
     assert(classof(kind));
   }
 
@@ -9081,13 +9094,13 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
 
 class OwnershipForwardingMultipleValueInstruction
     : public MultipleValueInstruction,
-      public OwnershipForwardingInst {
+      public OwnershipForwardingMixin {
 public:
   OwnershipForwardingMultipleValueInstruction(SILInstructionKind kind,
                                               SILDebugLocation loc,
                                               ValueOwnershipKind ownershipKind)
       : MultipleValueInstruction(kind, loc),
-        OwnershipForwardingInst(kind, ownershipKind) {
+        OwnershipForwardingMixin(kind, ownershipKind) {
     assert(classof(kind) && "Missing subclass from classof?!");
   }
 
@@ -9276,16 +9289,7 @@ inline bool Operand::isTypeDependent() const {
   return getUser()->isTypeDependentOperand(*this);
 }
 
-inline bool OwnershipForwardingInst::classof(const SILInstruction *inst) {
-  return FirstArgOwnershipForwardingSingleValueInst::classof(inst) ||
-         AllArgOwnershipForwardingSingleValueInst::classof(inst) ||
-         OwnershipForwardingTermInst::classof(inst) ||
-         OwnershipForwardingConversionInst::classof(inst) ||
-         OwnershipForwardingSelectEnumInstBase::classof(inst) ||
-         OwnershipForwardingMultipleValueInstruction::classof(inst);
-}
-
-inline bool OwnershipForwardingInst::classof(SILInstructionKind kind) {
+inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
   return FirstArgOwnershipForwardingSingleValueInst::classof(kind) ||
          AllArgOwnershipForwardingSingleValueInst::classof(kind) ||
          OwnershipForwardingTermInst::classof(kind) ||
@@ -9294,6 +9298,28 @@ inline bool OwnershipForwardingInst::classof(SILInstructionKind kind) {
          OwnershipForwardingMultipleValueInstruction::classof(kind);
 }
 
+inline OwnershipForwardingMixin *
+OwnershipForwardingMixin::get(SILInstruction *inst) {
+  // I am purposely performing this cast in this manner rather than reinterpret
+  // casting to OwnershipForwardingMixin to ensure that we offset to the
+  // appropriate offset inside of inst instead of converting inst's current
+  // location to an OwnershipForwardingMixin which would be incorrect.
+  if (auto *result = dyn_cast<FirstArgOwnershipForwardingSingleValueInst>(inst))
+    return result;
+  if (auto *result = dyn_cast<AllArgOwnershipForwardingSingleValueInst>(inst))
+    return result;
+  if (auto *result = dyn_cast<OwnershipForwardingTermInst>(inst))
+    return result;
+  if (auto *result = dyn_cast<OwnershipForwardingConversionInst>(inst))
+    return result;
+  if (auto *result = dyn_cast<OwnershipForwardingSelectEnumInstBase>(inst))
+    return result;
+  if (auto *result =
+          dyn_cast<OwnershipForwardingMultipleValueInstruction>(inst))
+    return result;
+  return nullptr;
+}
+
 } // end swift namespace
 
 //===----------------------------------------------------------------------===//