Merge pull request swiftlang#27117 from eeckstein/fix-memory-lifetime

MemoryLifetime: fix a problem where DestroyHoisting moved a destroy_addr before a use of a trivial type.

Author: eeckstein

docs/SIL.rst

@@ -2525,7 +2525,9 @@ except that ``destroy_addr`` may be used even if ``%0`` is of an
 address-only type.  This does not deallocate memory; it only destroys the
 pointed-to value, leaving the memory uninitialized.
 
-If ``T`` is a trivial type, then ``destroy_addr`` is a no-op.
+If ``T`` is a trivial type, then ``destroy_addr`` is a no-op. However, even a
+memory location ``%a`` with a trivial type must not be accessed after a
+``destroy_addr %a``.
 
 index_addr
 ``````````

include/swift/SIL/MemoryLifetime.h

@@ -131,12 +131,23 @@ class MemoryLocations {
     /// \endcode
     int parentIdx;
 
+  private:
+    friend class MemoryLocations;
+
     /// Used to decide if a location is completely covered by its sub-locations.
     ///
     /// -1 means: not yet initialized.
     int numFieldsNotCoveredBySubfields = -1;
 
+    /// The same as ``numFieldsNotCoveredBySubfields``, just for non-trivial
+    /// fields.
+    ///
+    /// -1 means: not yet initialized.
+    int numNonTrivialFieldsNotCovered = -1;
+
     Location(SILValue val, unsigned index, int parentIdx = -1);
+
+    void updateFieldCounters(SILType ty, int increment);
   };
 
 private:
@@ -156,6 +167,9 @@ class MemoryLocations {
   /// small. They can be handled separately with handleSingleBlockLocations().
   llvm::SmallVector<SingleValueInstruction *, 16> singleBlockLocations;
 
+  /// The bit-set of locations for which numNonTrivialFieldsNotCovered is > 0.
+  Bits nonTrivialLocations;
+
 public:
   MemoryLocations() {}
 
@@ -220,6 +234,10 @@ class MemoryLocations {
   void handleSingleBlockLocations(
                        std::function<void (SILBasicBlock *block)> handlerFunc);
 
+  /// Returns the set of locations for which have non trivial fields which are
+  /// not covered by sub-fields.
+  const Bits &getNonTrivialLocations();
+
   /// Debug dump the MemoryLifetime internals.
   void dump() const;
 
@@ -249,11 +267,6 @@ class MemoryLocations {
 
   /// Calculates Location::numFieldsNotCoveredBySubfields
   void initFieldsCounter(Location &loc);
-
-  /// Only memory locations which store a non-trivial type are considered.
-  bool shouldTrackLocation(SILType type, SILFunction *inFunction) {
-    return !type.isTrivial(*inFunction);
-  }
 };
 
 /// The MemoryDataflow utility calculates global dataflow of memory locations.