Merge pull request #36054 from eeckstein/memory-lifetime-for-enums

MemoryLifetimeVerifier: support verifying enum memory locations.

Author: eeckstein

docs/SIL.rst

@@ -2320,6 +2320,54 @@ The current list of interior pointer SIL instructions are:
 (*) We still need to finish adding support for project_box, but all other
 interior pointers are guarded already.
 
+Memory Lifetime
+~~~~~~~~~~~~~~~
+
+Similar to Ownership SSA, there are also lifetime rules for values in memory.
+With "memory" we refer to memory which is addressed by SIL instruction with
+address-type operands, like ``load``, ``store``, ``switch_enum_addr``, etc.
+
+Each memory location which holds a non-trivial value is either uninitialized
+or initialized. A memory location gets initialized by storing values into it
+(except assignment, which expects a location to be already initialized).
+A memory location gets de-initialized by "taking" from it or destroying it, e.g.
+with ``destroy_addr``. It is illegal to re-initialize a memory location or to
+use a location after it was de-initialized.
+
+If a memory location holds a trivial value (e.g. an ``Int``), it is not
+required to de-initialize the location.
+
+The SIL verifier checks this rule for memory locations which can be uniquely
+identified, for example and ``alloc_stack`` or an indirect parameter. The
+verifier cannot check memory locations which are potentially aliased, e.g.
+a ``ref_element_addr`` (a stored class property).
+
+Lifetime of Enums in Memory
+```````````````````````````
+
+The situation is a bit more complicated with enums, because an enum can have
+both, cases with non-trivial payloads and cases with no payload or trivial
+payloads.
+
+Even if an enum itself is not trivial (because it has at least on case with a
+non-trivial payload), it is not required to de-initialize such an enum memory
+location on paths where it's statically provable that the enum contains a
+trivial or non-payload case.
+
+That's the case if the destroy point is jointly dominated by:
+
+* a ``store [trivial]`` to the enum memory location.
+
+or
+
+* an ``inject_enum_addr`` to the enum memory location with a non-trivial or
+  non-payload case.
+
+or
+
+* a successor of a ``switch_enum`` or ``switch_enum_addr`` for a non-trivial
+  or non-payload case.
+
 Dead End Blocks
 ~~~~~~~~~~~~~~~
 

include/swift/SIL/MemoryLifetime.h

@@ -114,6 +114,11 @@ class MemoryLocations {
     /// Bit 2 is never set because Inner is completly represented by its
     /// sub-locations 3 and 4. But bit 0 is set in location 0 (the "self" bit),
     /// because it represents the untracked field ``Outer.z``.
+    ///
+    /// Single-payload enums are represented by a location with a single sub-
+    /// location (the projected payload address, i.e. an ``init_enum_data_addr``
+    /// or an ``unchecked_take_enum_data_addr``.
+    /// Multi-payload enums are not supported right now.
     Bits subLocations;
 
     /// The accumulated parent bits, including the "self" bit.
@@ -142,6 +147,12 @@ class MemoryLocations {
     /// \endcode
     int parentIdx;
 
+    /// Returns true if the location with index \p idx is this location or a
+    /// sub location of this location.
+    bool isSubLocation(unsigned idx) const {
+      return idx < subLocations.size() && subLocations.test(idx);
+    }
+
   private:
     friend class MemoryLocations;
 
@@ -178,11 +189,18 @@ 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;
+
 public:
-  MemoryLocations() {}
+  MemoryLocations(bool handleEnumDataProjections) :
+    handleEnumDataProjections(handleEnumDataProjections) {}
 
   MemoryLocations(const MemoryLocations &) = delete;
   MemoryLocations &operator=(const MemoryLocations &) = delete;
@@ -207,6 +225,9 @@ class MemoryLocations {
   const Location *getLocation(unsigned index) const {
     return &locations[index];
   }
+  
+  /// Returns the root location of \p index.
+  const Location *getRootLocation(unsigned index) const;
 
   /// Registers an address projection instruction for a location.
   void registerProjection(SingleValueInstruction *projection, unsigned locIdx) {
@@ -262,6 +283,15 @@ 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.
   ///