[AddressLowering] Prevent existential multi-init.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -439,7 +439,7 @@ void ValueStorage::dump() const {
   llvm::dbgs() << "isDefProjection: " << isDefProjection << "\n";
   llvm::dbgs() << "isUseProjection: " << isUseProjection << "\n";
   llvm::dbgs() << "isRewritten: " << isRewritten << "\n";
-  llvm::dbgs() << "initializesEnum: " << initializesEnum << "\n";
+  llvm::dbgs() << "initializes: " << initializes << "\n";
 }
 void ValueStorageMap::ValueStoragePair::dump() const {
   llvm::dbgs() << "value: ";
@@ -1071,8 +1071,9 @@ void ValueStorageMap::recordComposingUseProjection(Operand *oper,
 
   storage.isUseProjection = true;
 
-  if (userValue->getType().getEnumOrBoundGenericEnum()) {
-    storage.initializesEnum = true;
+  if (userValue->getType().getEnumOrBoundGenericEnum() ||
+      userValue->getType().isExistentialType()) {
+    storage.initializes = true;
   }
   assert(!storage.isPhiProjection());
 }
@@ -1266,8 +1267,8 @@ bool OpaqueStorageAllocation::findProjectionIntoUseImpl(
     // TODO: fix the memory verifier to consider the actual store instructions
     // to initialize an enum rather than the init_enum_data_addr to reuse enum
     // storage across multiple subobjects within the payload.
-    auto *baseStorage = pass.valueStorageMap.getBaseStorage(
-        userValue, /*allowInitEnum*/ !intoPhi);
+    auto *baseStorage =
+        pass.valueStorageMap.getBaseStorage(userValue, /*allowInit*/ !intoPhi);
     if (!baseStorage)
       continue;
 

lib/SILOptimizer/Mandatory/AddressLowering.h

@@ -147,15 +147,21 @@ struct ValueStorage {
   // The definition of this value is fully translated to lowered SIL.
   unsigned isRewritten : 1;
 
-  // This is a use-projection into an enum. Tracked to avoid projecting enums
-  // across phis, which would result in piecewise initialization.
-  unsigned initializesEnum : 1;
+  // This is a use-projection which performs an initialization side-effect,
+  // either into an enum or an existential.
+  //
+  // Tracked to avoid projecting enums/existentials across phis, which would
+  // result in piecewise initialization.
+  //
+  // Note that the corresponding value is the payload, not the
+  // enum instruction.
+  unsigned initializes : 1;
 
   ValueStorage(SILValue storageAddress): storageAddress(storageAddress) {
     isDefProjection = false;
     isUseProjection = false;
     isRewritten = false;
-    initializesEnum = false;
+    initializes = false;
 
     // The initial storage address is only valid when the value is effectively
     // already rewritten.
@@ -346,12 +352,13 @@ class ValueStorageMap {
   }
 
   /// Return the non-projection storage that this storage refers to.  If this
-  /// storage holds an Enum or any intermediate storage that projects into this
-  /// storage holds an Enum, then return nullptr.
-  const ValueStorage *getNonEnumBaseStorage(SILValue value) {
+  /// storage requires materializing an instruction that performs
+  /// initialization side effects (init_enum_data_addr, init_existential_addr),
+  /// return nullptr.
+  const ValueStorage *getNonInitializingBaseStorage(SILValue value) {
     for (auto *pair : getProjections(value)) {
       auto const &storage = pair->storage;
-      if (storage.initializesEnum)
+      if (storage.initializes)
         return nullptr;
 
       if (storage.isUseProjection) {
@@ -365,12 +372,12 @@ class ValueStorageMap {
   }
 
   /// Return the non-projection storage that this storage refers to, or nullptr
-  /// if \p allowInitEnum is true and the storage initializes an Enum.
-  const ValueStorage *getBaseStorage(SILValue value, bool allowInitEnum) {
-    if (allowInitEnum)
+  /// if \p allowInit is true and the storage initializes an Enum.
+  const ValueStorage *getBaseStorage(SILValue value, bool allowInit) {
+    if (allowInit)
       return &getBaseStorage(value);
 
-    return getNonEnumBaseStorage(value);
+    return getNonInitializingBaseStorage(value);
   }
 
   void setStorageAddress(SILValue value, SILValue addr) {