Make smaller stores generated for stores that are partly dead deterministic

We do not have problem right now because the we only do partial dead store when
we end up generating only 1 single smaller store.

Author: trentxintong

lib/SILOptimizer/Transforms/DeadStoreElimination.cpp

@@ -78,6 +78,12 @@
 
 using namespace swift;
 
+/// If a large store is broken down to too many smaller stores, bail out.
+/// Currently, we only do partial dead store if we can form a single contiguous
+/// non-dead store.
+static llvm::cl::opt<unsigned> MaxPartialStoreCount("max-partial-store-count",
+                                         llvm::cl::init(1), llvm::cl::Hidden);
+
 STATISTIC(NumDeadStores, "Number of dead stores removed");
 STATISTIC(NumPartialDeadStores, "Number of partial dead stores removed");
 
@@ -163,10 +169,6 @@ constexpr unsigned MaxLSLocationBBMultiplicationNone = 256*256;
 /// and 64 locations which is a sizeable function.
 constexpr unsigned MaxLSLocationBBMultiplicationPessimistic = 64*64;
 
-/// If a large store is broken down to too many smaller stores, bail out.
-/// Currently, we only do partial dead store if we can form a single contiguous
-/// non-dead store.
-constexpr unsigned MaxPartialDeadStoreCountLimit = 1;
 
 /// forward declaration.
 class DSEContext;
@@ -246,6 +248,7 @@ class BlockState {
   ///
   /// The first SILValue keeps the address of the live store and the second
   /// SILValue keeps the value of the store.
+  llvm::SetVector<SILValue> LiveAddr;
   llvm::DenseMap<SILValue, SILValue> LiveStores;
 
   /// Constructors.
@@ -956,7 +959,7 @@ void DSEContext::processWrite(SILInstruction *I, SILValue Val, SILValue Mem,
     LSLocation::reduce(L, Mod, Alives);
 
     // Oops, we have too many smaller stores generated, bail out.
-    if (Alives.size() > MaxPartialDeadStoreCountLimit)
+    if (Alives.size() > MaxPartialStoreCount)
       return;
 
     // At this point, we are performing a partial dead store elimination.
@@ -976,6 +979,7 @@ void DSEContext::processWrite(SILInstruction *I, SILValue Val, SILValue Mem,
     for (auto &X : Alives) {
       SILValue Value = X.getPath()->createExtract(Val, I, true);
       SILValue Addr = X.getPath()->createExtract(Mem, I, false);
+      S->LiveAddr.insert(Addr);
       S->LiveStores[Addr] = Value;
     }
 
@@ -1200,12 +1204,14 @@ bool DSEContext::run() {
   bool Changed = false;
   for (SILBasicBlock &BB : *F) {
     // Create the stores that are alive due to partial dead stores.
-    for (auto &I : getBlockState(&BB)->LiveStores) {
+    auto *S = getBlockState(&BB);
+    for (auto &X : S->LiveAddr) {
       Changed = true;
-      SILInstruction *Inst = cast<SILInstruction>(I.first);
+      auto I = S->LiveStores.find(X);
+      SILInstruction *Inst = cast<SILInstruction>(I->first);
       auto *IT = &*std::next(Inst->getIterator());
       SILBuilderWithScope Builder(IT);
-      Builder.createStore(Inst->getLoc(), I.second, Inst);
+      Builder.createStore(Inst->getLoc(), I->second, Inst);
     }
     // Delete the dead stores.
     for (auto &I : getBlockState(&BB)->DeadStores) {

test/SILOptimizer/dead_store_elim.sil

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt %s -dead-store-elim -enable-sil-verify-all | FileCheck %s
+// RUN: %target-sil-opt %s -dead-store-elim -max-partial-store-count=2 -enable-sil-verify-all | FileCheck %s
 
 sil_stage canonical
 
@@ -1075,6 +1075,28 @@ bb0(%0 : $*S6):
   return %9 : $()
 }
 
+/// Make sure we generate the store to field x first.
+///
+/// CHECK-LABEL : sil hidden @discontiguous_partial_dead_store_lives_insert_determinstically
+/// CHECK: bb0([[A:%.*]] : $*S6):
+/// CHECK: [[IN:%.*]] = apply
+/// CHECK: [[EXT1:%.*]] = struct_extract [[IN]] : $S6, #S6.x
+/// CHECK: [[EXT2:%.*]] =  struct_element_addr [[A]] : $*S6, #S6.x
+/// CHECK: store [[EXT1]] to [[EXT2]] : $*Int
+sil hidden @discontiguous_partial_dead_store_lives_insert_determinstically : $@convention(thin) (@inout S6) -> () {
+bb0(%0 : $*S6):
+  %1 = function_ref @S6_init : $@convention(thin) (@thin S6.Type) -> S6
+  %2 = metatype $@thin S6.Type
+  %3 = apply %1(%2) : $@convention(thin) (@thin S6.Type) -> S6
+  store %3 to %0 : $*S6
+  %5 = integer_literal $Builtin.Int64, 10
+  %6 = struct $Int (%5 : $Builtin.Int64)
+  %7 = struct_element_addr %0 : $*S6, #S6.y
+  store %6 to %7 : $*Int
+  %9 = tuple ()
+  return %9 : $()
+}
+
 /// Make sure we do not generate too many stores from a large store that
 /// is partially dead.
 ///