Fix PMO to not scalarize empty tuple

Currently PMO tries to scalarize empty tuple, and ends up deleting
store of an empty tuple. This causes a cascade of problems.
Mem2Reg can end up seeing loads without stores of empty tuple type,
and creates undef while optimizing the alloca away.
This is bad, we don't want to create undef's unnecessarily in SIL.
Some optimization can queiry the function or the block on the undef leading to nullptr
and a compiler crash.

Fixes rdar://94829482

Author: meg-gupta

lib/SILOptimizer/Mandatory/PMOMemoryUseCollector.cpp

@@ -278,19 +278,21 @@ bool ElementUseCollector::collectUses(SILValue Pointer) {
 
     // Loads are a use of the value.
     if (isa<LoadInst>(User) || isa<LoadBorrowInst>(User)) {
-      if (PointeeType.is<TupleType>())
+      if (PointeeType.is<TupleType>()) {
         UsesToScalarize.push_back(User);
-      else
+      } else
         Uses.emplace_back(User, PMOUseKind::Load);
       continue;
     }
 
     // Stores *to* the allocation are writes.
     if (auto *si = dyn_cast<StoreInst>(User)) {
       if (UI->getOperandNumber() == StoreInst::Dest) {
-        if (PointeeType.is<TupleType>()) {
-          UsesToScalarize.push_back(User);
-          continue;
+        if (auto tupleType = PointeeType.getAs<TupleType>()) {
+          if (!tupleType->isEqual(Module.getASTContext().TheEmptyTupleType)) {
+            UsesToScalarize.push_back(User);
+            continue;
+          }
         }
 
         auto kind = ([&]() -> PMOUseKind {
@@ -322,9 +324,11 @@ bool ElementUseCollector::collectUses(SILValue Pointer) {
     if (auto *CAI = dyn_cast<CopyAddrInst>(User)) {
       // If this is a copy of a tuple, we should scalarize it so that we don't
       // have an access that crosses elements.
-      if (PointeeType.is<TupleType>()) {
-        UsesToScalarize.push_back(CAI);
-        continue;
+      if (auto tupleType = PointeeType.getAs<TupleType>()) {
+        if (!tupleType->isEqual(Module.getASTContext().TheEmptyTupleType)) {
+          UsesToScalarize.push_back(CAI);
+          continue;
+        }
       }
 
       // If this is the source of the copy_addr, then this is a load.  If it is

test/SILOptimizer/predictable_memopt.sil

@@ -45,6 +45,34 @@ bb0(%0 : $Int):
   return %d : $Int
 }
 
+// CHECK-LABEL: sil @emptytuple_promotion1 : 
+// CHECK: store
+// CHECK-LABEL: } // end sil function 'emptytuple_promotion1'
+sil @emptytuple_promotion1 : $@convention(thin) () -> () {
+bb0:
+  %1 = alloc_stack $()
+  %2 = tuple ()
+  store %2 to %1 : $*()
+  dealloc_stack %1 : $*()
+  return %2 : $()
+}
+
+// CHECK-LABEL: sil @emptytuple_promotion2 : 
+// CHECK: store
+// CHECK: store
+// CHECK-LABEL: } // end sil function 'emptytuple_promotion2'
+sil @emptytuple_promotion2 : $@convention(thin) () -> () {
+bb0:
+  %1 = alloc_stack $()
+  %2 = alloc_stack $()
+  %3 = tuple ()
+  store %3 to %1 : $*()
+  copy_addr %2 to %1 : $*()
+  dealloc_stack %2 : $*()
+  dealloc_stack %1 : $*()
+  return %3 : $()
+}
+
 // In this example we create two boxes. The first box is initialized and then
 // taken from to initialize the second box. This means that the first box must
 // be dealloc_boxed (since its underlying memory is considered invalid). In