Merge pull request #36310 from eeckstein/memory-lifetime

Support all relevant address-instructions in MemoryLocations and the MemoryLifetimeVerifier

Author: eeckstein

include/swift/SIL/MemoryLifetime.h

@@ -189,18 +189,16 @@ class MemoryLocations {
   /// small. They can be handled separately with handleSingleBlockLocations().
   llvm::SmallVector<SingleValueInstruction *, 16> singleBlockLocations;
 
-  /// A Cache for single-payload enums.
-  llvm::DenseMap<SILType, EnumElementDecl *> singlePayloadEnums;
-
   /// The bit-set of locations for which numNonTrivialFieldsNotCovered is > 0.
   Bits nonTrivialLocations;
 
-  /// If true, support init_enum_data_addr and unchecked_take_enum_data_addr
-  bool handleEnumDataProjections;
+  /// If true, support init_enum_data_addr, unchecked_take_enum_data_addr,
+  /// init_existential_addr and open_existential_addr.
+  bool handleNonTrivialProjections;
 
 public:
-  MemoryLocations(bool handleEnumDataProjections) :
-    handleEnumDataProjections(handleEnumDataProjections) {}
+  MemoryLocations(bool handleNonTrivialProjections) :
+    handleNonTrivialProjections(handleNonTrivialProjections) {}
 
   MemoryLocations(const MemoryLocations &) = delete;
   MemoryLocations &operator=(const MemoryLocations &) = delete;
@@ -236,17 +234,31 @@ class MemoryLocations {
 
   /// Sets the location bits os \p addr in \p bits, if \p addr is associated
   /// with a location.
-  void setBits(Bits &bits, SILValue addr) {
+  void setBits(Bits &bits, SILValue addr) const {
     if (auto *loc = getLocation(addr))
       bits |= loc->subLocations;
   }
 
   /// Clears the location bits os \p addr in \p bits, if \p addr is associated
   /// with a location.
-  void clearBits(Bits &bits, SILValue addr) {
+  void clearBits(Bits &bits, SILValue addr) const {
     if (auto *loc = getLocation(addr))
       bits.reset(loc->subLocations);
   }
+  
+  void genBits(Bits &genSet, Bits &killSet, SILValue addr) const {
+    if (auto *loc = getLocation(addr)) {
+      killSet.reset(loc->subLocations);
+      genSet |= loc->subLocations;
+    }
+  }
+
+  void killBits(Bits &genSet, Bits &killSet, SILValue addr) const {
+    if (auto *loc = getLocation(addr)) {
+      killSet |= loc->subLocations;
+      genSet.reset(loc->subLocations);
+    }
+  }
 
   /// Analyzes all locations in a function.
   ///
@@ -283,15 +295,6 @@ class MemoryLocations {
   // (locationIdx, fieldNr) -> subLocationIdx
   using SubLocationMap = llvm::DenseMap<std::pair<unsigned, unsigned>, unsigned>;
 
-  /// Returns the payload case of a single-payload enum.
-  ///
-  /// Returns null if \p enumTy is not a single-payload enum.
-  /// We are currently only handling enum data projections for single-payload
-  /// enums, because it's much simpler to represent them with Locations. We
-  /// could also support multi-payload enums, but that gets complicated. Most
-  /// importantly, we can handle Swift.Optional.
-  EnumElementDecl *getSinglePayloadEnumCase(SILType enumTy);
-
   /// Helper function called by analyzeLocation to check all uses of the
   /// location recursively.
   ///
@@ -368,17 +371,11 @@ class MemoryDataflow {
     // Utility functions for setting and clearing gen- and kill-bits.
 
     void genBits(SILValue addr, const MemoryLocations &locs) {
-      if (auto *loc = locs.getLocation(addr)) {
-        killSet.reset(loc->subLocations);
-        genSet |= loc->subLocations;
-      }
+      locs.genBits(genSet, killSet, addr);
     }
 
     void killBits(SILValue addr, const MemoryLocations &locs) {
-      if (auto *loc = locs.getLocation(addr)) {
-        genSet.reset(loc->subLocations);
-        killSet |= loc->subLocations;
-      }
+      locs.killBits(genSet, killSet, addr);
     }
 
     bool exitReachable() const {

include/swift/SIL/SILInstruction.h

@@ -1009,6 +1009,19 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
            node->getKind() <= SILNodeKind::Last_##ID;                          \
   }
 
+/// Abstract base class which defines the source and destination operand numbers
+/// for copy-like instructions, like store, assign, copy_addr and cast
+/// instructions.
+class CopyLikeInstruction {
+public:
+  enum {
+    /// The source operand index.
+    Src,
+    /// The destination operand index.
+    Dest
+  };
+};
+
 /// Abstract base class used for isa checks on instructions to determine if they
 /// forward ownership and to verify that the set of ownership instructions and
 /// the ownership utilities stay in sync via assertions.
@@ -3823,7 +3836,8 @@ static_assert(2 == SILNode::NumStoreOwnershipQualifierBits, "Size mismatch");
 /// StoreInst - Represents a store from a memory location.
 class StoreInst
     : public InstructionBase<SILInstructionKind::StoreInst,
-                             NonValueInstruction> {
+                             NonValueInstruction>,
+      public CopyLikeInstruction {
   friend SILBuilder;
 
 private:
@@ -3833,13 +3847,6 @@ class StoreInst
             StoreOwnershipQualifier Qualifier);
 
 public:
-  enum {
-    /// the value being stored
-    Src,
-    /// the lvalue being stored to
-    Dest
-  };
-
   SILValue getSrc() const { return Operands[Src].get(); }
   SILValue getDest() const { return Operands[Dest].get(); }
 
@@ -3915,17 +3922,10 @@ inline auto BeginBorrowInst::getEndBorrows() const -> EndBorrowRange {
 /// address. Must be paired with an end_borrow in its use-def list.
 class StoreBorrowInst
     : public InstructionBase<SILInstructionKind::StoreBorrowInst,
-                             SingleValueInstruction> {
+                             SingleValueInstruction>,
+      public CopyLikeInstruction {
   friend class SILBuilder;
 
-public:
-  enum {
-    /// The source of the value being borrowed.
-    Src,
-    /// The destination of the borrowed value.
-    Dest
-  };
-
 private:
   FixedOperandList<2> Operands;
   StoreBorrowInst(SILDebugLocation DebugLoc, SILValue Src, SILValue Dest);
@@ -4326,7 +4326,8 @@ static_assert(2 == SILNode::NumAssignOwnershipQualifierBits, "Size mismatch");
 
 template <SILInstructionKind Kind, int NumOps>
 class AssignInstBase
-    : public InstructionBase<Kind, NonValueInstruction> {
+    : public InstructionBase<Kind, NonValueInstruction>,
+      public CopyLikeInstruction {
 
 protected:
   FixedOperandList<NumOps> Operands;
@@ -4337,13 +4338,6 @@ class AssignInstBase
       Operands(this, std::forward<T>(args)...) { }
 
 public:
-  enum {
-    /// the value being stored
-    Src,
-    /// the lvalue being stored to
-    Dest
-  };
-
   SILValue getSrc() const { return Operands[Src].get(); }
   SILValue getDest() const { return Operands[Dest].get(); }
 
@@ -4663,18 +4657,10 @@ class Store##Name##Inst \
 /// but a copy instruction must be used for address-only types.
 class CopyAddrInst
     : public InstructionBase<SILInstructionKind::CopyAddrInst,
-                             NonValueInstruction> {
+                             NonValueInstruction>,
+      public CopyLikeInstruction {
   friend SILBuilder;
 
-public:
-  enum {
-    /// The lvalue being loaded from.
-    Src,
-
-    /// The lvalue being stored to.
-    Dest
-  };
-
 private:
   FixedOperandList<2> Operands;
 
@@ -8657,7 +8643,8 @@ template<SILInstructionKind Kind,
          typename Base>
 class AddrCastInstBase
     : public InstructionBaseWithTrailingOperands<Kind, Derived,
-                                                 TypesForAddrCasts<Base>> {
+                                                 TypesForAddrCasts<Base>>,
+      public CopyLikeInstruction {
 protected:
   friend InstructionBaseWithTrailingOperands<Kind, Derived, Operand>;
 
@@ -8688,13 +8675,6 @@ class AddrCastInstBase
     return this->getAllOperands().slice(2);
   }
 
-  enum {
-    /// the value being stored
-    Src,
-    /// the lvalue being stored to
-    Dest
-  };
-
   SILValue getSrc() const { return this->getAllOperands()[Src].get(); }
   SILValue getDest() const { return this->getAllOperands()[Dest].get(); }