MemoryLifetimeVerifier: support verifying enum memory locations.

This is kind of complicated, because an enum can be trivial for one case and not trivial for another case. We need to check at which parts of the function we can prove that the enum does (or could) have a trivial case. In such a branch, it's not required in SIL to destroy the enum location.

Also, document the rules and requirements for enum memory locations in SIL.rst.

rdar://73770085

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.
   ///