[SILCombine] Dominance check for inject_enum_addr.

If stores of empty values to the address don't dominate the
inject_enum_addr, the inject_enum_addr can't be eliminated--it's the
only indication of the case that's in the address.

Author: nate-chandler

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -865,14 +865,20 @@ SILInstruction *SILCombiner::visitCondFailInst(CondFailInst *CFI) {
   return nullptr;
 }
 
-/// Create a value from stores to an address.
+/// Whether there exists a unique value to which \p addr is always initialized
+/// at \p forInst.
 ///
-/// If there are only stores to \p addr, return the stored value. Also, if there
-/// are address projections, create aggregate instructions for it.
-/// If builder is null, it's just a dry-run to check if it's possible.
-static SILValue createValueFromAddr(SILValue addr, SILBuilder *builder,
-                                    SILLocation loc) {
-  SmallVector<SILValue, 4> elems;
+/// If \p builder is passed, create the value using it.  If \p addr is
+/// initialized piecewise via initializations of tuple element memory, the full
+/// tuple is constructed via the builder.
+///
+/// A best effort.
+/// TODO: Construct structs.
+///       Handle stores of identical values on multiple paths.
+static std::optional<std::pair<SILValue, SILInstruction *>>
+createValueFromAddr(SILValue addr, SILInstruction *forInst, DominanceInfo *DI,
+                    SILBuilder *builder, SILLocation loc) {
+  SmallVector<std::optional<std::pair<SILValue, SILInstruction *>>, 4> pairs;
   enum Kind {
     none, store, tuple
   } kind = none;
@@ -884,7 +890,7 @@ static SILValue createValueFromAddr(SILValue addr, SILBuilder *builder,
 
     auto *st = dyn_cast<StoreInst>(user);
     if (st && kind == none && st->getDest() == addr) {
-      elems.push_back(st->getSrc());
+      pairs.push_back({{st->getSrc(), st}});
       kind = store;
       // We cannot just return st->getSrc() here because we also have to check
       // if the store destination is the only use of addr.
@@ -893,35 +899,55 @@ static SILValue createValueFromAddr(SILValue addr, SILBuilder *builder,
 
     if (auto *telem = dyn_cast<TupleElementAddrInst>(user)) {
       if (kind == none) {
-        elems.resize(addr->getType().castTo<TupleType>()->getNumElements());
+        pairs.resize(addr->getType().castTo<TupleType>()->getNumElements());
         kind = tuple;
       }
       if (kind == tuple) {
-        if (elems[telem->getFieldIndex()])
-          return SILValue();
-        elems[telem->getFieldIndex()] = createValueFromAddr(telem, builder, loc);
+        if (pairs[telem->getFieldIndex()]) {
+          // Already found a tuple_element_addr at this index.  Assume that a
+          // different value is stored to addr by it.
+          return std::nullopt;
+        }
+        pairs[telem->getFieldIndex()] =
+            createValueFromAddr(telem, forInst, DI, builder, loc);
         continue;
       }
     }
     // TODO: handle StructElementAddrInst to create structs.
 
-    return SILValue();
+    return std::nullopt;
   }
   switch (kind) {
   case none:
-    return SILValue();
+    return std::nullopt;
   case store:
-    assert(elems.size() == 1);
-    return elems[0];
+    assert(pairs.size() == 1);
+    {
+      auto pair = pairs[0];
+      assert(pair.has_value());
+      bool isEmpty = pair->first->getType().isEmpty(*addr->getFunction());
+      if (isEmpty && !DI->properlyDominates(pair->second, forInst))
+        return std::nullopt;
+      return pair;
+    }
   case tuple:
-    if (std::any_of(elems.begin(), elems.end(),
-                    [](SILValue v){ return !(bool)v; }))
-      return SILValue();
+    if (std::any_of(pairs.begin(), pairs.end(), [&](auto pair) {
+          return !pair.has_value() ||
+                 (pair->first->getType().isEmpty(*addr->getFunction()) &&
+                  !DI->properlyDominates(pair->second, forInst));
+        }))
+      return std::nullopt;
     if (builder) {
-      return builder->createTuple(loc, addr->getType().getObjectType(), elems);
+      SmallVector<SILValue, 4> elements;
+      for (auto pair : pairs) {
+        elements.push_back(pair->first);
+      }
+      auto *tuple =
+          builder->createTuple(loc, addr->getType().getObjectType(), elements);
+      return {{tuple, tuple}};
     }
     // Just return anything not null for the dry-run.
-    return elems[0];
+    return pairs[0];
   }
   llvm_unreachable("invalid kind");
 }
@@ -1185,9 +1211,12 @@ SILCombiner::visitInjectEnumAddrInst(InjectEnumAddrInst *IEAI) {
   //   store %payload1 to %elem1_addr
   //   inject_enum_addr %enum_addr, $EnumType.case
   //
-  if (createValueFromAddr(DataAddrInst, nullptr, DataAddrInst->getLoc())) {
-    SILValue en =
-      createValueFromAddr(DataAddrInst, &Builder, DataAddrInst->getLoc());
+  auto DI = DA->get(IEAI->getFunction());
+  if (createValueFromAddr(DataAddrInst, IEAI, DI, nullptr,
+                          DataAddrInst->getLoc())) {
+    SILValue en = createValueFromAddr(DataAddrInst, IEAI, DI, &Builder,
+                                      DataAddrInst->getLoc())
+                      ->first;
     assert(en);
 
     // In that case, create the payload enum/store.
@@ -1224,7 +1253,14 @@ SILCombiner::visitInjectEnumAddrInst(InjectEnumAddrInst *IEAI) {
   //  store %1 to %nopayload_addr
   //
   auto *AI = dyn_cast_or_null<ApplyInst>(getSingleNonDebugUser(DataAddrInst));
-  if (!AI)
+  bool hasEmptyAssociatedType =
+      IEAI->getElement()->hasAssociatedValues()
+          ? IEAI->getOperand()
+                ->getType()
+                .getEnumElementType(IEAI->getElement(), func)
+                .isEmpty(*func)
+          : false;
+  if (!AI || (hasEmptyAssociatedType && !DI->properlyDominates(AI, IEAI)))
     return nullptr;
 
   unsigned ArgIdx = 0;