[DSE,MemorySSA] Check if DomAccess is valid for elimination first.

[fhahn]

Summary

This changes getDomMemoryDef to check if a DomAccess is a valid
candidate for elimination before checking for reads. Before the change,
we were spending a lot of compile-time in checking for read accesses for
DomAccess that might not even be removable.

This patch flips the logic, so we skip DomAccesses if they cannot be
removed before checking all their uses. This is much more efficient in
practice.

It also adds a more aggressive limit for checking partially overlapping
stores. The main problem with overlapping stores is that we do not know
if they will lead to elimination until seeing all of them. This patch
limits adds a new limit for overlapping store candidates, which keeps
the number of modified overlapping stores roughly the same.

This is another substantial compile-time improvement (while also
increasing the number of stores eliminated). Geomean -O3 -0.67%,
ReleaseThinLTO -0.97%.

http://llvm-compile-time-tracker.com/compare.php?from=0a929b6978a068af8ddb02d0d4714a2843dd8ba9&to=2e630629b43f64b60b282e90f0d96082fde2dacc&stat=instructions

[xbolva00]

llvm/test/Transforms/DeadStoreElimination/MSSA/simple.ll

479–480

Remove todo?

[fhahn]

llvm/test/Transforms/DeadStoreElimination/MSSA/simple.ll

479–480

Thanks, that looks indeed fixed now :)

645

This change looks wrong, I'll fix that tomorrow.

[asbirlea]

llvm/test/Transforms/DeadStoreElimination/MSSA/combined-partial-overwrites.ll

293

Remove "aggressive"

299

Does it make sense to have a RUN line with the cl::opt increasing the limit for a few of the meaningful tests to show the difference? (with check-prefixes)

[fhahn]

Rebase, add check lines to overlap tests with increase partial store limit, add options for thresholds, thanks!

[fhahn]

llvm/test/Transforms/DeadStoreElimination/MSSA/simple.ll

479–480

Actually, the change was a problem and I think the TODO is invalid. I updated the comment to say we cannot remove store i32 1... because it may be read by the caller if unknown_func unwinds.

[fhahn]

Rebase after dropping getClobberingMemoryAccess from D86486

[asbirlea]

A few nits, but lgtm.

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

1828

nit: flip naming. Argument to StartAccess and local var that gets modified in loop to Current. Seems easier to follow IMO and it's only 2 lines to update.

1856

s/DomI/CurrentI to match above naming?

llvm/test/Transforms/DeadStoreElimination/MSSA/combined-partial-overwrites.ll

3

use --check-prefixes=CHECK,LARGER-LIMIT to avoid duplication of the check lines that are the same and highlight the optimizations missed by the default limit.

293

Update comment?

[fhahn]

Thanks!

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

1828

That makes more sense, thanks!

1856

Yes that should be updated as well. Adjusted before committing. Some for DomLoc.

llvm/test/Transforms/DeadStoreElimination/MSSA/combined-partial-overwrites.ll

3

I updated the tests to use --check-prefixes=CHECK,DEFAULT-LIMIT --check-prefixes=CHECK,LARGER-LIMIT respectively. Now CHECK prefixes are shared for all functions that do not change.

293

That must have slipped through, sorry about that. I also removed it from the copied comment in multiblock-overlap.ll

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

 STATISTIC(NumRedundantStores, "Number of redundant stores deleted");
 STATISTIC(NumFastStores, "Number of stores deleted");
 STATISTIC(NumFastOther, "Number of other instrs removed");
 STATISTIC(NumCompletePartials, "Number of stores dead by later partials");
 STATISTIC(NumModifiedStores, "Number of stores modified");
 STATISTIC(NumCFGChecks, "Number of stores modified");
 STATISTIC(NumCFGTries, "Number of stores modified");
 STATISTIC(NumCFGSuccess, "Number of stores modified");
+STATISTIC(NumGetDomMemoryDefPassed,
+          "Number of times a valid candidate is returned from getDomMemoryDef");
 STATISTIC(NumDomMemDefChecks,
           "Number iterations check for reads in getDomMemoryDef");
 
 DEBUG_COUNTER(MemorySSACounter, "dse-memoryssa",
               "Controls which MemoryDefs are eliminated.");
 
 static cl::opt<bool>
 EnablePartialOverwriteTracking("enable-dse-partial-overwrite-tracking",
static cl::opt<unsigned>
     MemorySSAScanLimit("dse-memoryssa-scanlimit", cl::init(150), cl::Hidden,
                        cl::desc("The number of memory instructions to scan for "
                                 "dead store elimination (default = 100)"));
 static cl::opt<unsigned> MemorySSAUpwardsStepLimit(
     "dse-memoryssa-walklimit", cl::init(70), cl::Hidden,
     cl::desc("The maximum number of steps while walking upwards to find "
              "MemoryDefs that may be killed (default = 70)"));
 
+static cl::opt<unsigned> MemorySSAPartialStoreLimit(
+    "dse-memoryssa-partial-store-limit", cl::init(5), cl::Hidden,
+    cl::desc("The maximum number candidates that only partially overwrite the "
+             "killing MemoryDef to consider"
+             " (default = 5)"));
+
 static cl::opt<unsigned> MemorySSADefsPerBlockLimit(
     "dse-memoryssa-defs-per-block-limit", cl::init(5000), cl::Hidden,
     cl::desc("The number of MemoryDefs we consider as candidates to eliminated "
              "other stores per basic block (default = 5000)"));
 
 static cl::opt<unsigned> MemorySSASameBBStepCost(
     "dse-memoryssa-samebb-cost", cl::init(1), cl::Hidden,
     cl::desc(

 // in between both MemoryDefs. A bit more concretely:
 //
 // For all MemoryDefs StartDef:
 // 1. Get the next dominating clobbering MemoryDef (EarlierAccess) by walking
 //    upwards.
 // 2. Check that there are no reads between EarlierAccess and the StartDef by
 //    checking all uses starting at EarlierAccess and walking until we see
 //    StartDef.
-// 3. For each found EarlierDef, check that:
-//   1. There are no barrier instructions between EarlierDef and StartDef (like
+// 3. For each found CurrentDef, check that:
+//   1. There are no barrier instructions between CurrentDef and StartDef (like
 //       throws or stores with ordering constraints).
-//   2. StartDef is executed whenever EarlierDef is executed.
-//   3. StartDef completely overwrites EarlierDef.
-// 4. Erase EarlierDef from the function and MemorySSA.
+//   2. StartDef is executed whenever CurrentDef is executed.
+//   3. StartDef completely overwrites CurrentDef.
+// 4. Erase CurrentDef from the function and MemorySSA.
 
 // Returns true if \p M is an intrisnic that does not read or write memory.
 bool isNoopIntrinsic(MemoryUseOrDef *M) {
   if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(M->getMemoryInst())) {
     switch (II->getIntrinsicID()) {
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
     case Intrinsic::invariant_end:
struct DSEState {
   // read access between them or on any other path to a function exit block if
   // \p DefLoc is not accessible after the function returns. If there is no such
   // MemoryDef, return None. The returned value may not (completely) overwrite
   // \p DefLoc. Currently we bail out when we encounter an aliasing MemoryUse
   // (read).
   Optional<MemoryAccess *>
   getDomMemoryDef(MemoryDef *KillingDef, MemoryAccess *Current,
                   MemoryLocation DefLoc, const Value *DefUO, CheckCache &Cache,
-                  unsigned &ScanLimit, unsigned &WalkerStepLimit) {
+                  unsigned &ScanLimit, unsigned &WalkerStepLimit,
+                  bool IsMemTerm, unsigned &PartialLimit) {
     if (ScanLimit == 0 || WalkerStepLimit == 0) {
       LLVM_DEBUG(dbgs() << "\n    ...  hit scan limit\n");
       return None;
     }
 
     MemoryAccess *StartAccess = Current;
+    Instruction *KillingI = KillingDef->getMemoryInst();
     bool StepAgain;
     LLVM_DEBUG(dbgs() << "  trying to get dominating access for " << *Current
                       << "\n");
+
     // Find the next clobbering Mod access for DefLoc, starting at Current.
     do {
       StepAgain = false;
       // Reached TOP.
       if (MSSA.isLiveOnEntryDef(Current))
         return None;
 
       // Cost of a step. Accesses in the same block are more likely to be valid
       // candidates for elimination, hence consider them cheaper.
       unsigned StepCost = KillingDef->getBlock() == Current->getBlock()
                               ? MemorySSASameBBStepCost
                               : MemorySSAOtherBBStepCost;
       if (WalkerStepLimit <= StepCost)
         return None;
       WalkerStepLimit -= StepCost;
 
       if (isa<MemoryPhi>(Current))
         break;
 
-      // Check if we can skip EarlierDef for DSE.
-      MemoryDef *CurrentDef = dyn_cast<MemoryDef>(Current);
-      if (CurrentDef &&
-          canSkipDef(CurrentDef, !isInvisibleToCallerBeforeRet(DefUO))) {
+      // Below, check if CurrentDef is a valid candidate to be eliminated by
+      // KillingDef. If it is not, check the next candidate.
+      MemoryDef *CurrentDef = cast<MemoryDef>(Current);
+      Instruction *DomI = CurrentDef->getMemoryInst();
+
+      if (canSkipDef(CurrentDef, !isInvisibleToCallerBeforeRet(DefUO))) {
+        StepAgain = true;
+        Current = CurrentDef->getDefiningAccess();
+        continue;
+      }
+
+      // Before we try to remove anything, check for any extra throwing
+      // instructions that block us from DSEing
+      if (mayThrowBetween(KillingI, DomI, DefUO)) {
+        LLVM_DEBUG(dbgs() << "  ... skip, may throw!\n");
+        return None;
+      }
+
+      // Check for anything that looks like it will be a barrier to further
+      // removal
+      if (isDSEBarrier(DefUO, DomI)) {
+        LLVM_DEBUG(dbgs() << "  ... skip, barrier\n");
+        return None;
+      }
+
+      // If Current is known to be on path that reads DefLoc or is a read
+      // clobber, bail out, as the path is not profitable. We skip this check
+      // for intrinsic calls, because the code knows how to handle memcpy
+      // intrinsics.
+      if (!isa<IntrinsicInst>(DomI) &&
+          (Cache.KnownReads.contains(Current) || isReadClobber(DefLoc, DomI))) {
+        Cache.KnownReads.insert(Current);
+        return None;
+      }
+
+      // If Current cannot be analyzed or is not removable, check the next
+      // candidate.
+      if (!hasAnalyzableMemoryWrite(DomI, TLI) || !isRemovable(DomI)) {
+        StepAgain = true;
+        Current = CurrentDef->getDefiningAccess();
+        continue;
+      }
+
+      auto DomLoc = getLocForWriteEx(DomI);
+      if (!DomLoc)
+        break;
+
+      if (IsMemTerm) {
+        // If the killing def is a memory terminator (e.g. lifetime.end), check
+        // the next candidate if the current Current does not write the same
+        // underlying object as the terminator.
+        const Value *NIUnd = getUnderlyingObject(DomLoc->Ptr);
+        if (DefUO != NIUnd) {
           StepAgain = true;
           Current = CurrentDef->getDefiningAccess();
         }
+        continue;
+      } else {
+        int64_t InstWriteOffset, DepWriteOffset;
+        auto OR = isOverwrite(DefLoc, *DomLoc, DL, TLI, DepWriteOffset,
+                              InstWriteOffset, BatchAA, &F);
+        // If Current does not write to the same object as KillingDef, check
+        // the next candidate.
+        if (OR == OW_Unknown) {
+          StepAgain = true;
+          Current = CurrentDef->getDefiningAccess();
+        } else if (OR == OW_MaybePartial) {
+          // If KillingDef only partially overwrites Current, check the next
+          // candidate if the partial step limit is exceeded. This aggressively
+          // limits the number of candidates for partial store elimination,
+          // which are less likely to be removable in the end.
+          if (PartialLimit <= 1) {
+            StepAgain = true;
+            Current = CurrentDef->getDefiningAccess();
+            WalkerStepLimit -= 1;
+            continue;
+          }
+          PartialLimit -= 1;
+        }
+      }
     } while (StepAgain);
 
     MemoryAccess *EarlierAccess = Current;
     // Accesses to objects accessible after the function returns can only be
     // eliminated if the access is killed along all paths to the exit. Collect
     // the blocks with killing (=completely overwriting MemoryDefs) and check if
     // they cover all paths from EarlierAccess to any function exit.
     SmallPtrSet<Instruction *, 16> KillingDefs;
for (unsigned I = 0; I < State.MemDefs.size(); I++) {
     }
 
     MemoryAccess *Current = KillingDef;
     LLVM_DEBUG(dbgs() << "Trying to eliminate MemoryDefs killed by "
                       << *KillingDef << " (" << *SI << ")\n");
 
     unsigned ScanLimit = MemorySSAScanLimit;
     unsigned WalkerStepLimit = MemorySSAUpwardsStepLimit;
+    unsigned PartialLimit = MemorySSAPartialStoreLimit;
     // Worklist of MemoryAccesses that may be killed by KillingDef.
     SetVector<MemoryAccess *> ToCheck;
     ToCheck.insert(KillingDef->getDefiningAccess());
 
+    if (!SILocUnd)
+      continue;
+    bool IsMemTerm = State.isMemTerminatorInst(SI);
     DSEState::CheckCache Cache;
     // Check if MemoryAccesses in the worklist are killed by KillingDef.
     for (unsigned I = 0; I < ToCheck.size(); I++) {
       Current = ToCheck[I];
       if (State.SkipStores.count(Current))
         continue;
 
-      Optional<MemoryAccess *> Next =
-          State.getDomMemoryDef(KillingDef, Current, SILoc, SILocUnd, Cache,
-                                ScanLimit, WalkerStepLimit);
+      Optional<MemoryAccess *> Next = State.getDomMemoryDef(
+          KillingDef, Current, SILoc, SILocUnd, Cache, ScanLimit,
+          WalkerStepLimit, IsMemTerm, PartialLimit);
 
       if (!Next) {
         LLVM_DEBUG(dbgs() << "  finished walk\n");
         continue;
       }
 
       MemoryAccess *EarlierAccess = *Next;
       LLVM_DEBUG(dbgs() << " Checking if we can kill " << *EarlierAccess);
for (unsigned I = 0; I < ToCheck.size(); I++) {
               State.PostOrderNumbers[PhiBlock])
             ToCheck.insert(IncomingAccess);
         }
         continue;
       }
       MemoryDef *NextDef = dyn_cast<MemoryDef>(EarlierAccess);
       Instruction *NI = NextDef->getMemoryInst();
       LLVM_DEBUG(dbgs() << " (" << *NI << ")\n");
-
-      // Before we try to remove anything, check for any extra throwing
-      // instructions that block us from DSEing
-      if (State.mayThrowBetween(SI, NI, SILocUnd)) {
-        LLVM_DEBUG(dbgs() << "  ... skip, may throw!\n");
-        break;
-      }
-
-      // Check for anything that looks like it will be a barrier to further
-      // removal
-      if (State.isDSEBarrier(SILocUnd, NI)) {
-        LLVM_DEBUG(dbgs() << "  ... skip, barrier\n");
-        continue;
-      }
-
       ToCheck.insert(NextDef->getDefiningAccess());
-
-      if (!hasAnalyzableMemoryWrite(NI, TLI)) {
-        LLVM_DEBUG(dbgs() << "  ... skip, cannot analyze def\n");
-        continue;
-      }
-
-      if (!isRemovable(NI)) {
-        LLVM_DEBUG(dbgs() << "  ... skip, cannot remove def\n");
-        continue;
-      }
+      NumGetDomMemoryDefPassed++;
 
       if (!DebugCounter::shouldExecute(MemorySSACounter))
         continue;
 
       MemoryLocation NILoc = *State.getLocForWriteEx(NI);
 
-      if (State.isMemTerminatorInst(SI)) {
+      if (IsMemTerm) {
         const Value *NIUnd = getUnderlyingObject(NILoc.Ptr);
-        if (!SILocUnd || SILocUnd != NIUnd)
+        if (SILocUnd != NIUnd)
           continue;
         LLVM_DEBUG(dbgs() << "DSE: Remove Dead Store:\n  DEAD: " << *NI
                           << "\n  KILLER: " << *SI << '\n');
         State.deleteDeadInstruction(NI);
         ++NumFastStores;
         MadeChange = true;
       } else {
         // Check if NI overwrites SI.

llvm/test/Transforms/DeadStoreElimination/MSSA/combined-partial-overwrites.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -dse -enable-dse-memoryssa -enable-dse-partial-store-merging=false < %s | FileCheck %s
+; RUN: opt -S -dse -enable-dse-memoryssa -enable-dse-partial-store-merging=false -dse-memoryssa-partial-store-limit=10 < %s | FileCheck --check-prefix=LARGER-LIMIT %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64le-unknown-linux"
 
 %"struct.std::complex" = type { { float, float } }
 
 define void @_Z4testSt7complexIfE(%"struct.std::complex"* noalias nocapture sret %agg.result, i64 %c.coerce) {
 ; CHECK-LABEL: @_Z4testSt7complexIfE(
 ; CHECK-NEXT:  entry:

 ; CHECK-NEXT:    [[MUL_I_I_I:%.*]] = fadd fast float [[MUL_AD_I_I]], [[MUL_BC_I_I]]
 ; CHECK-NEXT:    [[MUL_AC_I_I:%.*]] = fmul fast float [[TMP5]], [[TMP0]]
 ; CHECK-NEXT:    [[MUL_BD_I_I:%.*]] = fmul fast float [[TMP7]], [[TMP1]]
 ; CHECK-NEXT:    [[MUL_R_I_I:%.*]] = fsub fast float [[MUL_AC_I_I]], [[MUL_BD_I_I]]
 ; CHECK-NEXT:    store float [[MUL_R_I_I]], float* [[_M_VALUE_REALP_I_I]], align 4
 ; CHECK-NEXT:    store float [[MUL_I_I_I]], float* [[_M_VALUE_IMAGP_I_I]], align 4
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @_Z4testSt7complexIfE(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[REF_TMP:%.*]] = alloca i64, align 8
+; LARGER-LIMIT-NEXT:    [[TMPCAST:%.*]] = bitcast i64* [[REF_TMP]] to %"struct.std::complex"*
+; LARGER-LIMIT-NEXT:    [[C_SROA_0_0_EXTRACT_SHIFT:%.*]] = lshr i64 [[C_COERCE:%.*]], 32
+; LARGER-LIMIT-NEXT:    [[C_SROA_0_0_EXTRACT_TRUNC:%.*]] = trunc i64 [[C_SROA_0_0_EXTRACT_SHIFT]] to i32
+; LARGER-LIMIT-NEXT:    [[TMP0:%.*]] = bitcast i32 [[C_SROA_0_0_EXTRACT_TRUNC]] to float
+; LARGER-LIMIT-NEXT:    [[C_SROA_2_0_EXTRACT_TRUNC:%.*]] = trunc i64 [[C_COERCE]] to i32
+; LARGER-LIMIT-NEXT:    [[TMP1:%.*]] = bitcast i32 [[C_SROA_2_0_EXTRACT_TRUNC]] to float
+; LARGER-LIMIT-NEXT:    call void @_Z3barSt7complexIfE(%"struct.std::complex"* nonnull sret [[TMPCAST]], i64 [[C_COERCE]])
+; LARGER-LIMIT-NEXT:    [[TMP2:%.*]] = load i64, i64* [[REF_TMP]], align 8
+; LARGER-LIMIT-NEXT:    [[_M_VALUE_REALP_I_I:%.*]] = getelementptr inbounds %"struct.std::complex", %"struct.std::complex"* [[AGG_RESULT:%.*]], i64 0, i32 0, i32 0
+; LARGER-LIMIT-NEXT:    [[TMP3:%.*]] = lshr i64 [[TMP2]], 32
+; LARGER-LIMIT-NEXT:    [[TMP4:%.*]] = trunc i64 [[TMP3]] to i32
+; LARGER-LIMIT-NEXT:    [[TMP5:%.*]] = bitcast i32 [[TMP4]] to float
+; LARGER-LIMIT-NEXT:    [[_M_VALUE_IMAGP_I_I:%.*]] = getelementptr inbounds %"struct.std::complex", %"struct.std::complex"* [[AGG_RESULT]], i64 0, i32 0, i32 1
+; LARGER-LIMIT-NEXT:    [[TMP6:%.*]] = trunc i64 [[TMP2]] to i32
+; LARGER-LIMIT-NEXT:    [[TMP7:%.*]] = bitcast i32 [[TMP6]] to float
+; LARGER-LIMIT-NEXT:    [[MUL_AD_I_I:%.*]] = fmul fast float [[TMP5]], [[TMP1]]
+; LARGER-LIMIT-NEXT:    [[MUL_BC_I_I:%.*]] = fmul fast float [[TMP7]], [[TMP0]]
+; LARGER-LIMIT-NEXT:    [[MUL_I_I_I:%.*]] = fadd fast float [[MUL_AD_I_I]], [[MUL_BC_I_I]]
+; LARGER-LIMIT-NEXT:    [[MUL_AC_I_I:%.*]] = fmul fast float [[TMP5]], [[TMP0]]
+; LARGER-LIMIT-NEXT:    [[MUL_BD_I_I:%.*]] = fmul fast float [[TMP7]], [[TMP1]]
+; LARGER-LIMIT-NEXT:    [[MUL_R_I_I:%.*]] = fsub fast float [[MUL_AC_I_I]], [[MUL_BD_I_I]]
+; LARGER-LIMIT-NEXT:    store float [[MUL_R_I_I]], float* [[_M_VALUE_REALP_I_I]], align 4
+; LARGER-LIMIT-NEXT:    store float [[MUL_I_I_I]], float* [[_M_VALUE_IMAGP_I_I]], align 4
+; LARGER-LIMIT-NEXT:    ret void
+;
 entry:
 
   %ref.tmp = alloca i64, align 8
   %tmpcast = bitcast i64* %ref.tmp to %"struct.std::complex"*
   %c.sroa.0.0.extract.shift = lshr i64 %c.coerce, 32
   %c.sroa.0.0.extract.trunc = trunc i64 %c.sroa.0.0.extract.shift to i32
   %0 = bitcast i32 %c.sroa.0.0.extract.trunc to float
   %c.sroa.2.0.extract.trunc = trunc i64 %c.coerce to i32

 ; CHECK-NEXT:    store i16 -30062, i16* [[WPTR]], align 2
 ; CHECK-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 3
 ; CHECK-NEXT:    store i8 47, i8* [[BPTR3]], align 1
 ; CHECK-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 1
 ; CHECK-NEXT:    [[WPTRP:%.*]] = bitcast i8* [[BPTR1]] to i16*
 ; CHECK-NEXT:    store i16 2020, i16* [[WPTRP]], align 1
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @test1(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[BPTR:%.*]] = bitcast i32* [[PTR:%.*]] to i8*
+; LARGER-LIMIT-NEXT:    [[WPTR:%.*]] = bitcast i32* [[PTR]] to i16*
+; LARGER-LIMIT-NEXT:    store i16 -30062, i16* [[WPTR]], align 2
+; LARGER-LIMIT-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 3
+; LARGER-LIMIT-NEXT:    store i8 47, i8* [[BPTR3]], align 1
+; LARGER-LIMIT-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 1
+; LARGER-LIMIT-NEXT:    [[WPTRP:%.*]] = bitcast i8* [[BPTR1]] to i16*
+; LARGER-LIMIT-NEXT:    store i16 2020, i16* [[WPTRP]], align 1
+; LARGER-LIMIT-NEXT:    ret void
+;
 entry:
 
   store i32 5, i32* %ptr
   %bptr = bitcast i32* %ptr to i8*
   store i8 7, i8* %bptr
   %wptr = bitcast i32* %ptr to i16*
   store i16 -30062, i16* %wptr
   %bptr2 = getelementptr inbounds i8, i8* %bptr, i64 2

 ; CHECK-NEXT:    [[WPTR3:%.*]] = bitcast i8* [[BPTR3]] to i16*
 ; CHECK-NEXT:    store i16 1456, i16* [[WPTRM1]], align 1
 ; CHECK-NEXT:    store i16 1346, i16* [[WPTR]], align 1
 ; CHECK-NEXT:    store i16 1756, i16* [[WPTR1]], align 1
 ; CHECK-NEXT:    store i16 1126, i16* [[WPTR2]], align 1
 ; CHECK-NEXT:    store i16 5656, i16* [[WPTR3]], align 1
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @test2(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[BPTR:%.*]] = bitcast i32* [[PTR:%.*]] to i8*
+; LARGER-LIMIT-NEXT:    [[BPTRM1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 -1
+; LARGER-LIMIT-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 1
+; LARGER-LIMIT-NEXT:    [[BPTR2:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 2
+; LARGER-LIMIT-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 3
+; LARGER-LIMIT-NEXT:    [[WPTR:%.*]] = bitcast i8* [[BPTR]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTRM1:%.*]] = bitcast i8* [[BPTRM1]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR1:%.*]] = bitcast i8* [[BPTR1]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR2:%.*]] = bitcast i8* [[BPTR2]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR3:%.*]] = bitcast i8* [[BPTR3]] to i16*
+; LARGER-LIMIT-NEXT:    store i16 1456, i16* [[WPTRM1]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1346, i16* [[WPTR]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1756, i16* [[WPTR1]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1126, i16* [[WPTR2]], align 1
+; LARGER-LIMIT-NEXT:    store i16 5656, i16* [[WPTR3]], align 1
+; LARGER-LIMIT-NEXT:    ret void
+;
 entry:
 
   store i32 5, i32* %ptr
 
   %bptr = bitcast i32* %ptr to i8*
   %bptrm1 = getelementptr inbounds i8, i8* %bptr, i64 -1
   %bptr1 = getelementptr inbounds i8, i8* %bptr, i64 1
   %bptr2 = getelementptr inbounds i8, i8* %bptr, i64 2

 ; CHECK-NEXT:    [[V:%.*]] = load i8, i8* [[BPTR]], align 1
 ; CHECK-NEXT:    store i16 1456, i16* [[WPTRM1]], align 1
 ; CHECK-NEXT:    store i16 1346, i16* [[WPTR]], align 1
 ; CHECK-NEXT:    store i16 1756, i16* [[WPTR1]], align 1
 ; CHECK-NEXT:    store i16 1126, i16* [[WPTR2]], align 1
 ; CHECK-NEXT:    store i16 5656, i16* [[WPTR3]], align 1
 ; CHECK-NEXT:    ret i8 [[V]]
 ;
+; LARGER-LIMIT-LABEL: @test3(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    store i32 5, i32* [[PTR:%.*]], align 4
+; LARGER-LIMIT-NEXT:    [[BPTR:%.*]] = bitcast i32* [[PTR]] to i8*
+; LARGER-LIMIT-NEXT:    [[BPTRM1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 -1
+; LARGER-LIMIT-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 1
+; LARGER-LIMIT-NEXT:    [[BPTR2:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 2
+; LARGER-LIMIT-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 3
+; LARGER-LIMIT-NEXT:    [[WPTR:%.*]] = bitcast i8* [[BPTR]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTRM1:%.*]] = bitcast i8* [[BPTRM1]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR1:%.*]] = bitcast i8* [[BPTR1]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR2:%.*]] = bitcast i8* [[BPTR2]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR3:%.*]] = bitcast i8* [[BPTR3]] to i16*
+; LARGER-LIMIT-NEXT:    [[V:%.*]] = load i8, i8* [[BPTR]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1456, i16* [[WPTRM1]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1346, i16* [[WPTR]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1756, i16* [[WPTR1]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1126, i16* [[WPTR2]], align 1
+; LARGER-LIMIT-NEXT:    store i16 5656, i16* [[WPTR3]], align 1
+; LARGER-LIMIT-NEXT:    ret i8 [[V]]
+;
 entry:
 
   store i32 5, i32* %ptr
 
   %bptr = bitcast i32* %ptr to i8*
   %bptrm1 = getelementptr inbounds i8, i8* %bptr, i64 -1
   %bptr1 = getelementptr inbounds i8, i8* %bptr, i64 1
   %bptr2 = getelementptr inbounds i8, i8* %bptr, i64 2

 i32 (i8*, i8**, i32, i8, i8*)*,
 i32 (i8*, i8**, i32, i8, i8*)*,
 void (i8*, i32, i32)*
 }
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1)
 declare void @goFunc(%struct.foostruct*)
 declare i32 @fa(i8*, i8**, i32, i8, i8*)
 
+; We miss this case, because of aggressive an aggressive limit of partial
+; overlap analysis. With a larger partial store limit, we remove the memset.
 define void @test4()  {
 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[BANG:%.*]] = alloca [[STRUCT_FOOSTRUCT:%.*]], align 8
+; CHECK-NEXT:    [[V1:%.*]] = bitcast %struct.foostruct* [[BANG]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[V1]], i64 32
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 8 [[TMP0]], i8 0, i64 8, i1 false)
 ; CHECK-NEXT:    [[V2:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 0
 ; CHECK-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V2]], align 8
 ; CHECK-NEXT:    [[V3:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 1
 ; CHECK-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V3]], align 8
 ; CHECK-NEXT:    [[V4:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 2
 ; CHECK-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V4]], align 8
 ; CHECK-NEXT:    [[V5:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 3
 ; CHECK-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V5]], align 8
 ; CHECK-NEXT:    [[V6:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 4
 ; CHECK-NEXT:    store void (i8*, i32, i32)* null, void (i8*, i32, i32)** [[V6]], align 8
 ; CHECK-NEXT:    call void @goFunc(%struct.foostruct* [[BANG]])
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @test4(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[BANG:%.*]] = alloca [[STRUCT_FOOSTRUCT:%.*]], align 8
+; LARGER-LIMIT-NEXT:    [[V2:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 0
+; LARGER-LIMIT-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V2]], align 8
+; LARGER-LIMIT-NEXT:    [[V3:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 1
+; LARGER-LIMIT-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V3]], align 8
+; LARGER-LIMIT-NEXT:    [[V4:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 2
+; LARGER-LIMIT-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V4]], align 8
+; LARGER-LIMIT-NEXT:    [[V5:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 3
+; LARGER-LIMIT-NEXT:    store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V5]], align 8
+; LARGER-LIMIT-NEXT:    [[V6:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 4
+; LARGER-LIMIT-NEXT:    store void (i8*, i32, i32)* null, void (i8*, i32, i32)** [[V6]], align 8
+; LARGER-LIMIT-NEXT:    call void @goFunc(%struct.foostruct* [[BANG]])
+; LARGER-LIMIT-NEXT:    ret void
+;
 entry:
 
   %bang = alloca %struct.foostruct, align 8
   %v1 = bitcast %struct.foostruct* %bang to i8*
   call void @llvm.memset.p0i8.i64(i8* align 8 %v1, i8 0, i64 40, i1 false)
   %v2 = getelementptr inbounds %struct.foostruct, %struct.foostruct* %bang, i64 0, i32 0
   store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** %v2, align 8
   %v3 = getelementptr inbounds %struct.foostruct, %struct.foostruct* %bang, i64 0, i32 1

 ; CHECK-NEXT:    [[WPTR:%.*]] = bitcast i8* [[BPTR]] to i16*
 ; CHECK-NEXT:    [[WPTR1:%.*]] = bitcast i8* [[BPTR1]] to i16*
 ; CHECK-NEXT:    [[WPTR2:%.*]] = bitcast i8* [[BPTR2]] to i16*
 ; CHECK-NEXT:    store i16 -1, i16* [[WPTR2]], align 1
 ; CHECK-NEXT:    store i16 1456, i16* [[WPTR1]], align 1
 ; CHECK-NEXT:    store i16 1346, i16* [[WPTR]], align 1
 ; CHECK-NEXT:    ret i8 0
 ;
+; LARGER-LIMIT-LABEL: @test5(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[BPTR:%.*]] = bitcast i32* [[PTR:%.*]] to i8*
+; LARGER-LIMIT-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 1
+; LARGER-LIMIT-NEXT:    [[BPTR2:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 2
+; LARGER-LIMIT-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i8, i8* [[BPTR]], i64 3
+; LARGER-LIMIT-NEXT:    [[WPTR:%.*]] = bitcast i8* [[BPTR]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR1:%.*]] = bitcast i8* [[BPTR1]] to i16*
+; LARGER-LIMIT-NEXT:    [[WPTR2:%.*]] = bitcast i8* [[BPTR2]] to i16*
+; LARGER-LIMIT-NEXT:    store i16 -1, i16* [[WPTR2]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1456, i16* [[WPTR1]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1346, i16* [[WPTR]], align 1
+; LARGER-LIMIT-NEXT:    ret i8 0
+;
 entry:
 
   store i32 0, i32* %ptr
 
   %bptr = bitcast i32* %ptr to i8*
   %bptr1 = getelementptr inbounds i8, i8* %bptr, i64 1
   %bptr2 = getelementptr inbounds i8, i8* %bptr, i64 2
   %bptr3 = getelementptr inbounds i8, i8* %bptr, i64 3

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[BPTR:%.*]] = bitcast i32* [[PTR:%.*]] to i16*
 ; CHECK-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 0
 ; CHECK-NEXT:    [[BPTR2:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 1
 ; CHECK-NEXT:    store i16 1456, i16* [[BPTR2]], align 1
 ; CHECK-NEXT:    store i16 -1, i16* [[BPTR1]], align 1
 ; CHECK-NEXT:    ret i8 0
 ;
+; LARGER-LIMIT-LABEL: @test6(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[BPTR:%.*]] = bitcast i32* [[PTR:%.*]] to i16*
+; LARGER-LIMIT-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 0
+; LARGER-LIMIT-NEXT:    [[BPTR2:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 1
+; LARGER-LIMIT-NEXT:    store i16 1456, i16* [[BPTR2]], align 1
+; LARGER-LIMIT-NEXT:    store i16 -1, i16* [[BPTR1]], align 1
+; LARGER-LIMIT-NEXT:    ret i8 0
+;
 entry:
 
   store i32 0, i32* %ptr
 
   %bptr = bitcast i32* %ptr to i16*
   %bptr1 = getelementptr inbounds i16, i16* %bptr, i64 0
   %bptr2 = getelementptr inbounds i16, i16* %bptr, i64 1
 

 ; CHECK-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 2
 ; CHECK-NEXT:    [[BPTR4:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 3
 ; CHECK-NEXT:    store i16 1346, i16* [[BPTR1]], align 1
 ; CHECK-NEXT:    store i16 1756, i16* [[BPTR3]], align 1
 ; CHECK-NEXT:    store i16 1456, i16* [[BPTR2]], align 1
 ; CHECK-NEXT:    store i16 5656, i16* [[BPTR4]], align 1
 ; CHECK-NEXT:    ret i8 0
 ;
+; LARGER-LIMIT-LABEL: @test7(
+; LARGER-LIMIT-NEXT:  entry:
+; LARGER-LIMIT-NEXT:    [[BPTR:%.*]] = bitcast i64* [[PTR:%.*]] to i16*
+; LARGER-LIMIT-NEXT:    [[BPTR1:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 0
+; LARGER-LIMIT-NEXT:    [[BPTR2:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 1
+; LARGER-LIMIT-NEXT:    [[BPTR3:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 2
+; LARGER-LIMIT-NEXT:    [[BPTR4:%.*]] = getelementptr inbounds i16, i16* [[BPTR]], i64 3
+; LARGER-LIMIT-NEXT:    store i16 1346, i16* [[BPTR1]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1756, i16* [[BPTR3]], align 1
+; LARGER-LIMIT-NEXT:    store i16 1456, i16* [[BPTR2]], align 1
+; LARGER-LIMIT-NEXT:    store i16 5656, i16* [[BPTR4]], align 1
+; LARGER-LIMIT-NEXT:    ret i8 0
+;
 entry:
 
   store i64 0, i64* %ptr
 
   %bptr = bitcast i64* %ptr to i16*
   %bptr1 = getelementptr inbounds i16, i16* %bptr, i64 0
   %bptr2 = getelementptr inbounds i16, i16* %bptr, i64 1
   %bptr3 = getelementptr inbounds i16, i16* %bptr, i64 2

llvm/test/Transforms/DeadStoreElimination/MSSA/debug-counter.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
-; XFAIL: *
-
 ; REQUIRES: asserts
 
 ; Eliminates store to %R in the entry block.
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP0-COUNT1 %s
 
 ; Eliminates store to %P in the entry block.
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -debug-counter=dse-memoryssa-skip=1,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP1-COUNT1 %s
 

llvm/test/Transforms/DeadStoreElimination/MSSA/memoryssa-scan-limit.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
-; XFAIL: *
-
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck --check-prefix=NO-LIMIT %s
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -dse-memoryssa-scanlimit=0 -S | FileCheck --check-prefix=LIMIT-0 %s
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -dse-memoryssa-scanlimit=2 -S | FileCheck --check-prefix=LIMIT-2 %s
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -dse-memoryssa-scanlimit=3 -S | FileCheck --check-prefix=LIMIT-3 %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 

llvm/test/Transforms/DeadStoreElimination/MSSA/multiblock-overlap.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -dse -enable-dse-memoryssa %s -S | FileCheck %s
+; RUN: opt -dse -enable-dse-memoryssa -dse-memoryssa-partial-store-limit=10 %s -S | FileCheck --check-prefix=LARGER-LIMIT %s
 
 
 %struct.ham = type { [3 x double], [3 x double]}
 
 declare void @may_throw()
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg)
 
+; We miss this case, because of aggressive an aggressive limit of partial
+; overlap analysis.
 define void @overlap1(%struct.ham* %arg, i1 %cond) {
 ; CHECK-LABEL: @overlap1(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 0, i64 2
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 0
 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 2
 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 1
 ; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i32 0
+; CHECK-NEXT:    [[TMP6:%.*]] = bitcast double* [[TMP2]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[TMP6]], i64 32
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(48) [[TMP0]], i8 0, i64 16, i1 false)
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB7:%.*]], label [[BB8:%.*]]
 ; CHECK:       bb7:
 ; CHECK-NEXT:    br label [[BB9:%.*]]
 ; CHECK:       bb8:
 ; CHECK-NEXT:    br label [[BB9]]
 ; CHECK:       bb9:
 ; CHECK-NEXT:    store double 1.000000e+00, double* [[TMP2]], align 8
 ; CHECK-NEXT:    store double 2.000000e+00, double* [[TMP1]], align 8
 ; CHECK-NEXT:    store double 3.000000e+00, double* [[TMP]], align 8
 ; CHECK-NEXT:    store double 4.000000e+00, double* [[TMP5]], align 8
 ; CHECK-NEXT:    store double 5.000000e+00, double* [[TMP4]], align 8
 ; CHECK-NEXT:    store double 6.000000e+00, double* [[TMP3]], align 8
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @overlap1(
+; LARGER-LIMIT-NEXT:  bb:
+; LARGER-LIMIT-NEXT:    [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 0, i64 2
+; LARGER-LIMIT-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 1
+; LARGER-LIMIT-NEXT:    [[TMP2:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 0
+; LARGER-LIMIT-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 2
+; LARGER-LIMIT-NEXT:    [[TMP4:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 1
+; LARGER-LIMIT-NEXT:    [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i32 0
+; LARGER-LIMIT-NEXT:    br i1 [[COND:%.*]], label [[BB7:%.*]], label [[BB8:%.*]]
+; LARGER-LIMIT:       bb7:
+; LARGER-LIMIT-NEXT:    br label [[BB9:%.*]]
+; LARGER-LIMIT:       bb8:
+; LARGER-LIMIT-NEXT:    br label [[BB9]]
+; LARGER-LIMIT:       bb9:
+; LARGER-LIMIT-NEXT:    store double 1.000000e+00, double* [[TMP2]], align 8
+; LARGER-LIMIT-NEXT:    store double 2.000000e+00, double* [[TMP1]], align 8
+; LARGER-LIMIT-NEXT:    store double 3.000000e+00, double* [[TMP]], align 8
+; LARGER-LIMIT-NEXT:    store double 4.000000e+00, double* [[TMP5]], align 8
+; LARGER-LIMIT-NEXT:    store double 5.000000e+00, double* [[TMP4]], align 8
+; LARGER-LIMIT-NEXT:    store double 6.000000e+00, double* [[TMP3]], align 8
+; LARGER-LIMIT-NEXT:    ret void
+;
 bb:
   %tmp = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 2
   %tmp1 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 1
   %tmp2 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 0
   %tmp3 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0,i32 1, i64 2
   %tmp4 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i64 1
   %tmp5 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i32 0
   %tmp6 = bitcast double* %tmp2 to i8*

 ; CHECK-NEXT:    store double 1.000000e+00, double* [[TMP2]], align 8
 ; CHECK-NEXT:    store double 2.000000e+00, double* [[TMP1]], align 8
 ; CHECK-NEXT:    store double 3.000000e+00, double* [[TMP]], align 8
 ; CHECK-NEXT:    store double 4.000000e+00, double* [[TMP5]], align 8
 ; CHECK-NEXT:    store double 5.000000e+00, double* [[TMP4]], align 8
 ; CHECK-NEXT:    store double 6.000000e+00, double* [[TMP3]], align 8
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @overlap2(
+; LARGER-LIMIT-NEXT:  bb:
+; LARGER-LIMIT-NEXT:    [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 0, i64 2
+; LARGER-LIMIT-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 1
+; LARGER-LIMIT-NEXT:    [[TMP2:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 0
+; LARGER-LIMIT-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 2
+; LARGER-LIMIT-NEXT:    [[TMP4:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 1
+; LARGER-LIMIT-NEXT:    [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i32 0
+; LARGER-LIMIT-NEXT:    [[TMP6:%.*]] = bitcast double* [[TMP2]] to i8*
+; LARGER-LIMIT-NEXT:    call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(48) [[TMP6]], i8 0, i64 48, i1 false)
+; LARGER-LIMIT-NEXT:    br i1 [[COND:%.*]], label [[BB7:%.*]], label [[BB8:%.*]]
+; LARGER-LIMIT:       bb7:
+; LARGER-LIMIT-NEXT:    call void @may_throw()
+; LARGER-LIMIT-NEXT:    br label [[BB9:%.*]]
+; LARGER-LIMIT:       bb8:
+; LARGER-LIMIT-NEXT:    br label [[BB9]]
+; LARGER-LIMIT:       bb9:
+; LARGER-LIMIT-NEXT:    store double 1.000000e+00, double* [[TMP2]], align 8
+; LARGER-LIMIT-NEXT:    store double 2.000000e+00, double* [[TMP1]], align 8
+; LARGER-LIMIT-NEXT:    store double 3.000000e+00, double* [[TMP]], align 8
+; LARGER-LIMIT-NEXT:    store double 4.000000e+00, double* [[TMP5]], align 8
+; LARGER-LIMIT-NEXT:    store double 5.000000e+00, double* [[TMP4]], align 8
+; LARGER-LIMIT-NEXT:    store double 6.000000e+00, double* [[TMP3]], align 8
+; LARGER-LIMIT-NEXT:    ret void
+;
 bb:
   %tmp = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 2
   %tmp1 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 1
   %tmp2 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 0
   %tmp3 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0,i32 1, i64 2
   %tmp4 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i64 1
   %tmp5 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i32 0
   %tmp6 = bitcast double* %tmp2 to i8*

 ; CHECK-NEXT:    [[CAST_I32:%.*]] = bitcast [4 x i8]* [[ARG:%.*]] to i32*
 ; CHECK-NEXT:    store i32 844283136, i32* [[CAST_I32]], align 4
 ; CHECK-NEXT:    br label [[BB13]]
 ; CHECK:       bb13:
 ; CHECK-NEXT:    [[CAST_I16:%.*]] = bitcast [4 x i8]* [[ARG]] to i16*
 ; CHECK-NEXT:    store i16 0, i16* [[CAST_I16]], align 4
 ; CHECK-NEXT:    ret void
 ;
+; LARGER-LIMIT-LABEL: @overlap_no_dominance(
+; LARGER-LIMIT-NEXT:  bb:
+; LARGER-LIMIT-NEXT:    br i1 [[C:%.*]], label [[BB13:%.*]], label [[BB9:%.*]]
+; LARGER-LIMIT:       bb9:
+; LARGER-LIMIT-NEXT:    [[CAST_I32:%.*]] = bitcast [4 x i8]* [[ARG:%.*]] to i32*
+; LARGER-LIMIT-NEXT:    store i32 844283136, i32* [[CAST_I32]], align 4
+; LARGER-LIMIT-NEXT:    br label [[BB13]]
+; LARGER-LIMIT:       bb13:
+; LARGER-LIMIT-NEXT:    [[CAST_I16:%.*]] = bitcast [4 x i8]* [[ARG]] to i16*
+; LARGER-LIMIT-NEXT:    store i16 0, i16* [[CAST_I16]], align 4
+; LARGER-LIMIT-NEXT:    ret void
+;
 bb:
   br i1 %c, label %bb13, label %bb9
 
 bb9:                                              ; preds = %bb
   %cast.i32 = bitcast [4 x i8]* %arg to i32*
   store i32 844283136, i32* %cast.i32, align 4
   br label %bb13
 
 bb13:                                             ; preds = %bb9, %bb
   %cast.i16 = bitcast [4 x i8]* %arg to i16*
   store i16 0, i16* %cast.i16, align 4
   ret void
 }

llvm/test/Transforms/DeadStoreElimination/MSSA/simple.ll

 bb1:
   store i32 %v, i32* %p, align 4
   ; Might read and overwrite value at %p
   call void @unknown_func()
   br i1 undef, label %bb1, label %bb2
 bb2:
   ret i32 0
 }
 
-; TODO
-; We can remove redundant store, as noalias %p guarantees that the function does
-; only access it via %p. This also holds for the call to unknown_func even though
-; it could unwind
+; We cannot remove any stores, because @unknown_func may unwind and the caller
+; may read %p while unwinding.
 define void @test34(i32* noalias %p) {
 ; CHECK-LABEL: @test34(
 ; CHECK-NEXT:    store i32 1, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    call void @unknown_func()
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, i32* %p
entry:
   %Pc = load i8*, i8** %0, align 8
   %Qc = bitcast i32* %Q to i8*
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %Ac, i8* align 4 %Qc, i64 4, i1 false)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %Pc, i8* nonnull align 4 %Ac, i64 4, i1 true)
   call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %Ac)
   ret void
 }
 
-; I think this case is currently handled incorrectly by memdeps dse
-; throwing should leave store i32 1, not remove from the free.
 declare void @free(i8* nocapture)
+
+; We cannot remove `store i32 1, i32* %p`, because @unknown_func may unwind
+; and the caller may read %p while unwinding.
 define void @test41(i32* noalias %P) {
 ; CHECK-LABEL: @test41(
 ; CHECK-NEXT:    [[P2:%.*]] = bitcast i32* [[P:%.*]] to i8*
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    call void @unknown_func()
 ; CHECK-NEXT:    call void @free(i8* [[P2]])
 ; CHECK-NEXT:    ret void
 ;
   %P2 = bitcast i32* %P to i8*
   store i32 1, i32* %P
   call void @unknown_func()
   store i32 2, i32* %P