[DSE] Switch to MemorySSA-backed DSE by default.

[fhahn]

Summary

The tests have been updated and I plan to move them from the MSSA
directory up.

Some end-to-end tests needed small adjustments. One difference to the
legacy DSE is that legacy DSE also deletes trivially dead instructions
that are unrelated to memory operations. Because MemorySSA-backed DSE
just walks the MemorySSA, we only visit/check memory instructions. But
removing unrelated dead instructions is not really DSE's job and other
passes will clean up.

One noteworthy change is in llvm/test/Transforms/Coroutines/ArgAddr.ll,
but I think this comes down to legacy DSE not handling instructions that
may throw correctly in that case. To cover this with MemorySSA-backed
DSE, we need an update to llvm.coro.begin to treat it's return value to
belong to the same underlying object as the passed pointer.

There are some minor cases MemorySSA-backed DSE currently misses, e.g. related
to atomic operations, but I think those can be implemented after the switch.

This has been discussed on llvm-dev:
http://lists.llvm.org/pipermail/llvm-dev/2020-August/144417.html

For the MultiSource/SPEC2000/SPEC2006 the number of eliminated stores
goes from ~17500 (legayc DSE) to ~26300 (MemorySSA-backed). More numbers
and details in the thread on llvm-dev.

Impact on CTMark:

                                     Legacy Pass Manager
                        exec instrs    size-text
O3                       + 0.60%        - 0.27%
ReleaseThinLTO           + 1.00%        - 0.42%
ReleaseLTO-g.            + 0.77%        - 0.33%
RelThinLTO (link only)   + 0.87%        - 0.42%
RelLO-g (link only)      + 0.78%        - 0.33%

http://llvm-compile-time-tracker.com/compare.php?from=3f22e96d95c71ded906c67067d75278efb0a2525&to=ae8be4642533ff03803967ee9d7017c0d73b0ee0&stat=instructions

                                     New Pass Manager
                       exec instrs.   size-text
O3                       + 0.95%       - 0.25%
ReleaseThinLTO           + 1.34%       - 0.41%
ReleaseLTO-g.            + 1.71%       - 0.35%
RelThinLTO (link only)   + 0.96%       - 0.41%
RelLO-g (link only)      + 2.21%       - 0.35%

http://195.201.131.214:8000/compare.php?from=3f22e96d95c71ded906c67067d75278efb0a2525&to=ae8be4642533ff03803967ee9d7017c0d73b0ee0&stat=instructions

[xbolva00]

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

115

Default 150?

[fhahn]

Adjust limit in description, thanks!

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

115

Yes indeed, fixed!

[fhahn]

Note that we now also have to compute the PostDominatorTree, which adds an extra bit of compile-time overhead. By adjusting the pipeline a bit more, we can re-use ADCE's PDTs in most cases, which gives a -0.18% geomean improvement for -O3 D87322 http://llvm-compile-time-tracker.com/compare.php?from=15fdd6cd7c24c745df1bb419e72ff66fd138aa7e&to=481f494515fc89cb7caea8d862e40f2c910dc994&stat=instructions

Ideally we would preserve the PDT, but my first try with using DomTreeUpdater introduced a significant compile-time regression, so I put that on hold for now.

I don't think it is worth holding off flipping the default for those changes. They can be done as follow-ups I think and there probably will also be a few other small issues to iron out. The compile-time numbers shared are without the recent improvements to MemDepAnalysis (which sped up legacy DSE a bit), so the temporary change will be slightly bigger.

[fhahn]

rebase on top of latest changes.

[fhahn]

As another data point, I have collected compile-time numbers for ARM64 with -Os -g LTO & -Oz -g LTO. Geoman changes below. Compile time here is actual execution time on a stabilized system.

                 Compile time     code size
-Oz RLTO           0.67%             -0.12%
-Os -g RLTO        0.06%             -0.14%

I think flipping the switch now should be reasonable compile-time wise and we also have some ideas on how to reduce compile-time even further once it is enabled by default.

[xbolva00]

Thanks, amazing work!

I agree that this should be enabled now and do not wait anymore.

@nikic @spatel ?

[nikic]

LGTM as well, per llvm-dev discussion. I think you've done all the due diligence we can expect.

Do you plan to also work on MSSA-based MemCpyOpt? I expect that one will have a large positive impact on Rust code, where lack of cross-BB memcpy elision is a big issue right now.

[asbirlea]

Green light from me as well. I think there's still room for improvement for the NPM, but this is the right step to move forward infrastructure-wise.

Regarding the MemCpyOpt question from nikic@, please let me know if you want to take that over.

[fhahn]

It looks like a recently introduced GVN crash is exposed by this change (probably D87061). I will commit once this is fixed.

In D87163#2263685, @nikic wrote:

LGTM as well, per llvm-dev discussion. I think you've done all the due diligence we can expect.

Do you plan to also work on MSSA-based MemCpyOpt? I expect that one will have a large positive impact on Rust code, where lack of cross-BB memcpy elision is a big issue right now.

I probably won't have time to work on MSSA-based MemCpyOpt for the next couple of weeks unfortunately. But I think there is a lot that can be re-used/shared from the DSE implementation. Happy to discuss approaches.

[asbirlea]

I'm running into a crash with this, could you please hold off until tomorrow? I'm working on getting a reproducer.

[asbirlea]

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

316

The crash is hitting this unreachable for the intrinsic "llvm.memcpy.inline".
Simple repro: opt -dse test1.ll

define void @test(i8* noalias nocapture %0, i8* noalias nocapture readonly %1) {
  tail call void @llvm.memcpy.inline(i8* align 1 %0, i8* align 1 %1, i64 3, i1 false)
  ret void
}

declare void @llvm.memcpy.inline(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64 immarg, i1 immarg)

[fhahn]

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

316

Thanks! The problem was that MemorySSA-based DSE only relies on whether we can find read/write memory locations. For memcpy.inline, MemoryLocation knows how to extract the arguments, but the DSE functions where not updated to account for that.

In the legacy DSE, we silently failed to optimized/eliminate memcpy.inline calls, but with the MemorySSA version we got a crash highlighting that the code needs updating.

That should be fixed by a5ec99da6ea7

[fhahn]

In D87163#2264785, @asbirlea wrote:

I'm running into a crash with this, could you please hold off until tomorrow? I'm working on getting a reproducer.

@asbirlea Thanks for the reproducer, the issue should be sorted out. The GVN issue has also been fixed and I am planning to submit this today, unless you think we should wait a bit longer.

[fhahn]

Final rebase after new memcpy test.

[asbirlea]

I'm running additional testing in the background. I don't have anything holding this back at this point.
Either check in and if something shows up, I'll let you know to resolve or revert, or wait another 1-2 days for the testing I'm running to complete.
I'm ok with either option, and may even be inclined for the former, because there may be additional parties coming forward if issues arise, and I'd like these to come up earlier rather than later.

[fhahn]

In D87163#2266725, @asbirlea wrote:

I'm running additional testing in the background. I don't have anything holding this back at this point.
Either check in and if something shows up, I'll let you know to resolve or revert, or wait another 1-2 days for the testing I'm running to complete.
I'm ok with either option, and may even be inclined for the former, because there may be additional parties coming forward if issues arise, and I'd like these to come up earlier rather than later.

SGTM, I expect a few hiccups and it's probably best to get started early. I'll commit shortly.

[thakis]

The fix-up breaks tests: http://45.33.8.238/linux/27687/step_12.txt

[fhahn]

In D87163#2269674, @thakis wrote:

The fix-up breaks tests: http://45.33.8.238/linux/27687/step_12.txt

Thanks, should already be fixed in d85ac6d577ac

[thakis]

Heads-up: We're seeing fairly widespread test failures with this in Chromium that go away when we force this flag off. It's possible that it's due to only a small number of issues and they might be previously-benign UB (no idea), but I figured I'd give an early note. We'll send an update once we've reduced a failing test.

[uabelho]

Hi,

I'm seeing what I think is a miscompile with this:

opt -S -dse -o - dse.ll

on

@x = global [10 x [10 x i16]] zeroinitializer, align 1

define i16 @f() {
entry:
  br label %do.body

do.body:                                          ; preds = %if.end, %entry
  %i.0 = phi i16 [ 0, %entry ], [ %inc, %if.end ]
  %j.0 = phi i16 [ 0, %entry ], [ %add, %if.end ]
  %arrayidx2 = getelementptr inbounds [10 x [10 x i16]], [10 x [10 x i16]]* @x, i16 0, i16 %i.0, i16 %j.0
  store i16 2, i16* %arrayidx2, align 1
  %exitcond = icmp eq i16 %i.0, 4
  br i1 %exitcond, label %if.end10, label %if.end

if.end:                                           ; preds = %do.body
  %inc = add nuw nsw i16 %i.0, 1
  %add = add nuw nsw i16 %j.0, 2
  br label %do.body

if.end10:                                         ; preds = %do.body
  store i16 1, i16* %arrayidx2, align 1
  ret i16 0
}

gives

x = global [10 x [10 x i16]] zeroinitializer, align 1

define i16 @f() {
entry:
  br label %do.body

do.body:                                          ; preds = %if.end, %entry
  %i.0 = phi i16 [ 0, %entry ], [ %inc, %if.end ]
  %j.0 = phi i16 [ 0, %entry ], [ %add, %if.end ]
  %arrayidx2 = getelementptr inbounds [10 x [10 x i16]], [10 x [10 x i16]]* @x, i16 0, i16 %i.0, i16 %j.0
  %exitcond = icmp eq i16 %i.0, 4
  br i1 %exitcond, label %if.end10, label %if.end

if.end:                                           ; preds = %do.body
  %inc = add nuw nsw i16 %i.0, 1
  %add = add nuw nsw i16 %j.0, 2
  br label %do.body

if.end10:                                         ; preds = %do.body
  store i16 1, i16* %arrayidx2, align 1
  ret i16 0
}

So the store in the loop has been removed, which I think is incorrect.
The

store i16 2

in the loop should be carried out at (i,j) == (0,0), (1,2), (2,4), (3,6) och (4,8) and then the last of them should be overwritten by the

store i16 1

after the loop, but now the store in the loop is removed so we're only left with a written 1 at (4,8).

[fhahn]

In D87163#2270568, @uabelho wrote:

Hi,

I'm seeing what I think is a miscompile with this:

Thanks for the reproducer. We have to be more careful around pointers that may reference multiple locations in memory. I pushed f715d81c9df3 which limits elimination to stores that only reference a single location (or are in the same BB). The check is conservative and can be improved in the future, but the impact on the number of stores eliminated seems very low in practice. It would be great if you could check if that fixes the original reproducer.

[fhahn]

In D87163#2270444, @thakis wrote:

Heads-up: We're seeing fairly widespread test failures with this in Chromium that go away when we force this flag off. It's possible that it's due to only a small number of issues and they might be previously-benign UB (no idea), but I figured I'd give an early note. We'll send an update once we've reduced a failing test.

Thanks for the heads-up. I just pushed another fix for the issue @uabelho. I'd guess at least some of the failures you are seeing should be related. If not, I think it makes sense to revert this once we have the reproducers and can work in ironing out the remaining issues.

[uabelho]

In D87163#2270860, @fhahn wrote:

In D87163#2270568, @uabelho wrote:

Hi,

I'm seeing what I think is a miscompile with this:

Thanks for the reproducer. We have to be more careful around pointers that may reference multiple locations in memory. I pushed f715d81c9df3 which limits elimination to stores that only reference a single location (or are in the same BB). The check is conservative and can be improved in the future, but the impact on the number of stores eliminated seems very low in practice. It would be great if you could check if that fixes the original reproducer.

Great! I'll check and get back during the day.

[uabelho]

In D87163#2270918, @uabelho wrote:

In D87163#2270860, @fhahn wrote:

In D87163#2270568, @uabelho wrote:

Hi,

I'm seeing what I think is a miscompile with this:

Thanks for the reproducer. We have to be more careful around pointers that may reference multiple locations in memory. I pushed f715d81c9df3 which limits elimination to stores that only reference a single location (or are in the same BB). The check is conservative and can be improved in the future, but the impact on the number of stores eliminated seems very low in practice. It would be great if you could check if that fixes the original reproducer.

Great! I'll check and get back during the day.

Yep, the original reproducer passes now. Thanks!

[dmajor]

In D87163#2270871, @fhahn wrote:

In D87163#2270444, @thakis wrote:

Heads-up: We're seeing fairly widespread test failures with this in Chromium that go away when we force this flag off. It's possible that it's due to only a small number of issues and they might be previously-benign UB (no idea), but I figured I'd give an early note. We'll send an update once we've reduced a failing test.

Thanks for the heads-up. I just pushed another fix for the issue @uabelho. I'd guess at least some of the failures you are seeing should be related. If not, I think it makes sense to revert this once we have the reproducers and can work in ironing out the remaining issues.

We're also seeing test failures in Firefox that are not fixed by f715d81c9df3. I'll attempt to reduce but it may take some time.

[fhahn]

In D87163#2271998, @dmajor wrote:

In D87163#2270871, @fhahn wrote:

In D87163#2270444, @thakis wrote:

Heads-up: We're seeing fairly widespread test failures with this in Chromium that go away when we force this flag off. It's possible that it's due to only a small number of issues and they might be previously-benign UB (no idea), but I figured I'd give an early note. We'll send an update once we've reduced a failing test.

Thanks for the heads-up. I just pushed another fix for the issue @uabelho. I'd guess at least some of the failures you are seeing should be related. If not, I think it makes sense to revert this once we have the reproducers and can work in ironing out the remaining issues.

We're also seeing test failures in Firefox that are not fixed by f715d81c9df3. I'll attempt to reduce but it may take some time.

I also pushed a fix for a MemorySSA issue that was exposed through DSE + MemorySSA in c4f1b3144184. This might also fix (some) of the failures you are seeing.

[dmajor]

In D87163#2272105, @fhahn wrote:

I also pushed a fix for a MemorySSA issue that was exposed through DSE + MemorySSA in c4f1b3144184. This might also fix (some) of the failures you are seeing.

Same failures with c4f1b3144184.

[asbirlea]

I'd suggest reverting if the failures are blocking, but we do need a reproducer so it can be recommitted after a fix is in place.

[fhahn]

In D87163#2272749, @asbirlea wrote:

I'd suggest reverting if the failures are blocking, but we do need a reproducer so it can be recommitted after a fix is in place.

+1, but I think ideally we would have reproducers for the remaining issues first. @dmajor @thakis please let me know if this is blocking you and it is not feasible to provide reproducers before reverting.

[thakis]

It's not blocking us because we added an explicit flag to force this off to our build config for "normal" builds. (We still get the default-on behavior on our bots that build with trunk clang.) But if others are seeing problems with this too, I think it makes sense to revert so others don't spend time tracking down miscompiles to this commit.

Sadly our ToT bots were broken all day yesterday because someone broke -Warray-bounds in clang. That got reverted 5h ago, but our bots need 6-7h to cycle, so we don't know how our tests look at clang trunk.

(The last build before the -Warray-bounds issue also timed out during compile, so it's possible that that's a real issue and if so then the current build will also time out during compile and we'll have to analyze and fix that first before we get data about the state of our tests.)

[fhahn]

In D87163#2273917, @thakis wrote:

It's not blocking us because we added an explicit flag to force this off to our build config for "normal" builds. (We still get the default-on behavior on our bots that build with trunk clang.) But if others are seeing problems with this too, I think it makes sense to revert so others don't spend time tracking down miscompiles to this commit.

Sadly our ToT bots were broken all day yesterday because someone broke -Warray-bounds in clang. That got reverted 5h ago, but our bots need 6-7h to cycle, so we don't know how our tests look at clang trunk.

Ok, if you could let me know once you have some results, that would be great. If there still are problems, I'll go ahead an revert the patch later today.

[dmajor]

Here is a reduced-ish repro, I can keep poking at it but maybe this is sufficient for you to notice something: https://godbolt.org/z/endf6d.

Center pane is old DSE, right pane is new DSE. I highlighted the problem area with a nop at line 56 of the source, and line 59 of each disassembly. The array writes following the nop have been eliminated, even though they will be needed on a future iteration of the for loop.

[dmajor]

Reduced a bit more: https://godbolt.org/z/j59evK (C++) and https://godbolt.org/z/8xG688 (IR) -- the store at line 43 of while.end has been removed.

[fhahn]

In D87163#2274549, @dmajor wrote:

Reduced a bit more: https://godbolt.org/z/j59evK (C++) and https://godbolt.org/z/8xG688 (IR) -- the store at line 43 of while.end has been removed.

Thanks! I reverted the change for now in fb109c42d91c.

I think the problem here is that the load in the loop has liveOnEntry as defining access (which is outside the loop), so according to MemorySSA, the load does not read the memory written by the store. A slightly further IR example with the MemorySSA printed: https://godbolt.org/z/G34oM4. I think this is similar to the issue https://bugs.llvm.org/show_bug.cgi?id=47498.

@asbirlea do you have any thoughts on the issue? Do I understand correctly that in the example, %use = load i32, i32* %ptr.1, align 4 should have ; 8 = MemoryPhi({entry,1},{loop.latch,7}) as defining access?

define i32 @test() {
entry:
  %nodeStack = alloca [12 x i32], align 4
  %nodeStack.cast = bitcast [12 x i32]* %nodeStack to i8*
; 1 = MemoryDef(liveOnEntry)
  %c.1 = call i1 @cond(i32 1)
  br i1 %c.1, label %cleanup, label %loop.header

loop.header:                                      ; preds = %loop.latch, %entry
; 8 = MemoryPhi({entry,1},{loop.latch,7})
  %depth.1 = phi i32 [ %depth.1.be, %loop.latch ], [ 0, %entry ]
  %cmp = icmp sgt i32 %depth.1, 0
  br i1 %cmp, label %cond.read, label %cond.store

cond.read:                                        ; preds = %loop.header
  %sub = add nsw i32 %depth.1, -1
  %ptr.1 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %sub
; MemoryUse(liveOnEntry)
  %use = load i32, i32* %ptr.1, align 4
; 2 = MemoryDef(8)
  %c.2 = call i1 @cond(i32 %use)
  br i1 %c.2, label %loop.latch, label %cond.store

cond.store:                                       ; preds = %cond.read, %loop.header
; 9 = MemoryPhi({loop.header,8},{cond.read,2})
  %ptr.2 = getelementptr inbounds [12 x i32], [12 x i32]* %nodeStack, i32 0, i32 %depth.1
; 3 = MemoryDef(9)
  store i32 10, i32* %ptr.2, align 4
  %inc = add nsw i32 %depth.1, 1
; 4 = MemoryDef(3)
  %c.3 = call i1 @cond(i32 20)
  br i1 %c.3, label %cleanup, label %loop.latch

loop.latch:                                       ; preds = %cond.store, %cond.read
; 7 = MemoryPhi({cond.read,2},{cond.store,4})
  %depth.1.be = phi i32 [ %sub, %cond.read ], [ %inc, %cond.store ]
  br label %loop.header

cleanup:                                          ; preds = %cond.store, %entry
; 6 = MemoryPhi({entry,1},{cond.store,4})
; 5 = MemoryDef(6)
  call void @llvm.lifetime.end.p0i8(i64 48, i8* nonnull %nodeStack.cast)
  ret i32 20
}

[asbirlea]

Yes, the load should have the Phi as the defining access. I'm still looking into where this information should come from, but it's not hitting the phi translation.
Thank you for the revert, I'll update with the fix once I have it available.

[fhahn]

In D87163#2275058, @asbirlea wrote:

Yes, the load should have the Phi as the defining access. I'm still looking into where this information should come from, but it's not hitting the phi translation.
Thank you for the revert, I'll update with the fix once I have it available.

Thanks! I also started looking into where things go wrong. It appears that this happens during MemorySSA use optimization. (https://github.com/llvm/llvm-project/blob/master/llvm/lib/Analysis/MemorySSA.cpp#L1447). It seems like getClobberingMemoryAccess does not account for the fact that the query location could map to multiple memory locations if it is loop dependent. Just querying AA for both pointers will return noalias, because they only alias for different concrete phi values. I am not sure if we have a safe way to detect that a location actually refers to a range of locations. I am currently experimenting with being more conservative in getClobberingMemoryAccess for locations for which we cannot prove that they are loop-invariant for possible cycle in the function.

[asbirlea]

Right!
I believe the solution is to set the location size to unknown after a phi translation with the same ptr, but I need to properly verify that.

// include/llvm/Analysis/MemorySSA.h:1233
CurrentPair.second = Location.getWithNewSize(LocationSize::unknown());
return

[asbirlea]

I checked in a fix in https://reviews.llvm.org/rGfc8200633122, but I haven't yet verified it addresses all the failures reported.

[dmajor]

In D87163#2275896, @asbirlea wrote:

I checked in a fix in https://reviews.llvm.org/rGfc8200633122, but I haven't yet verified it addresses all the failures reported.

Thanks, I've confirmed that this fixes our tests in their original form (not reduced).

Our day-to-day testing of LLVM trunk is limited though, maybe one-tenth of our full suite. Since this code has some risks, I could start a full run to throw more testing at it. But that takes more machine capacity and human effort to remove flaky failures, so I'd prefer to wait until the odds are good that there won't be further changes. Let me know when you think it's ready.

[fhahn]

In D87163#2276899, @dmajor wrote:

In D87163#2275896, @asbirlea wrote:

I checked in a fix in https://reviews.llvm.org/rGfc8200633122, but I haven't yet verified it addresses all the failures reported.

Thanks, I've confirmed that this fixes our tests in their original form (not reduced).

Our day-to-day testing of LLVM trunk is limited though, maybe one-tenth of our full suite. Since this code has some risks, I could start a full run to throw more testing at it. But that takes more machine capacity and human effort to remove flaky failures, so I'd prefer to wait until the odds are good that there won't be further changes. Let me know when you think it's ready.

I think I managed to come up with another test case that unfortunately is not covered by the recent fix. I think we might need to be even more conservative when walking across MemoryPhis and put up D87778, which includes the test case, which is crafted so that the result of PHI translation dominate the relevant blocks during translation.

[fhahn]

All reported problems should be fixed now and we also made the fix for the issue @dmajor reported more conservative to catch more problematic cases. I just enabled DSE + MemorySSA again in 9d172c8e9c84. Please let me know if there are any further issues.

[dmajor]

Thanks for the heads up. I'll schedule a more intensive test run over the weekend while there's less demand for machines.

[dmajor]

I threw as many tests as I could find at 9d172c8e9c84, and I don't see any regressions compared to its parent revision.

[fhahn]

In D87163#2285984, @dmajor wrote:

I threw as many tests as I could find at 9d172c8e9c84, and I don't see any regressions compared to its parent revision.

That's great to know, thank you very much! And thanks everybody for providing very helpful test cases.

[fhahn]

FYI this has been temporarily reverted again roughly a week ago, because there seems to be a mis-compile, that is caused by LLVM introducing invalid lifetime.end calls and exposed by the more powerful DSE, which @asbirlea is currently trying to narrow down.

[fhahn]

I put up an impromptu round-table to discuss MemorySSA related topics, including potential new transformations like MemCpyOpt using MemorySSA: https://whova.com/portal/webapp/llvm_202010/CommunityBoard/topic/342030/

If there's any interest, I think it would be great to sync up.

[uabelho]

Hi!

I found a new problem after this was turned on again in 51ff04567b2f.
With

opt -S -o - bbi-49235.ll -memoryssa -gvn -dse -verify-memoryssa

I hit

opt: ../lib/Analysis/MemorySSA.cpp:2063: void llvm::MemorySSA::verifyOrderingDominationAndDefUses(llvm::Function &) const: Assertion `&*ALI == *AAI && "Not the same accesses in the same order"' failed.

with bbi-49235.ll being

define void @k() {
entry:
  %tobool = icmp ne i16 1, 0
  %0 = xor i1 %tobool, true
  call void @llvm.assume(i1 %0)
  call void @f()
  ret void
}

declare void @f() local_unnamed_addr

; Function Attrs: nofree nosync nounwind willreturn
declare void @llvm.assume(i1 noundef) #0

attributes #0 = { nofree nosync nounwind willreturn }

[uabelho]

In D87163#2373580, @uabelho wrote:

Hi!

I found a new problem after this was turned on again in 51ff04567b2f.

I wrote https://bugs.llvm.org/show_bug.cgi?id=48072 about it

[thakis]

Very belated update: We've been running with this on our clang/tot bots for a few weeks now and turned this on (or, more accurately stopped turning it off) for "normal" builds today. All tests pass and so far everything's happy.

[fhahn]

In D87163#2379892, @thakis wrote:

Very belated update: We've been running with this on our clang/tot bots for a few weeks now and turned this on (or, more accurately stopped turning it off) for "normal" builds today. All tests pass and so far everything's happy.

That's great, thanks for letting us know! There might be a few more features down the road, so it's good to know that you were able to make the initial switch.

[uabelho]

I wrote
https://bugs.llvm.org/show_bug.cgi?id=49859
about a miscompile that started occuring when turning on memoryssa again in DSE.
I suspect that licm doesn't keep memoryssa updated properly.

clang/test/CodeGen/thinlto-distributed-newpm.ll

 ; CHECK-O: Running pass: MemCpyOptPass on main
 ; CHECK-O: Running pass: SCCPPass on main
 ; CHECK-O: Running pass: BDCEPass on main
 ; CHECK-O: Running analysis: DemandedBitsAnalysis on main
 ; CHECK-O: Running pass: InstCombinePass on main
 ; CHECK-O: Running pass: JumpThreadingPass on main
 ; CHECK-O: Running pass: CorrelatedValuePropagationPass on main
 ; CHECK-O: Running pass: DSEPass on main
+; CHECK-O: Running analysis: PostDominatorTreeAnalysis on main
 ; CHECK-O: Starting {{.*}}Function pass manager run.
 ; CHECK-O: Running pass: LoopSimplifyPass on main
 ; CHECK-O: Running pass: LCSSAPass on main
 ; CHECK-O: Finished {{.*}}Function pass manager run.
 ; CHECK-O: Running pass: ADCEPass on main
-; CHECK-O: Running analysis: PostDominatorTreeAnalysis on main
 ; CHECK-O: Running pass: SimplifyCFGPass on main
 ; CHECK-O: Running pass: InstCombinePass on main
 ; CHECK-O: Finished {{.*}}Function pass manager run.
 ; CHECK-O: Finished CGSCC pass manager run.
 ; CHECK-O: Invalidating analysis: DominatorTreeAnalysis on main
 ; CHECK-O: Invalidating analysis: BasicAA on main
 ; CHECK-O: Invalidating analysis: AAManager on main
 ; CHECK-O: Invalidating analysis: MemorySSAAnalysis on main

clang/test/CodeGenObjC/exceptions.m

int f2() {
   // CHECK-NEXT:   br i1 [[CAUGHT]]
   @try {
     // Landing pad.  Note that we elide the re-enter.
     // CHECK:      call void asm sideeffect "", "=*m,=*m"(i32* nonnull [[X]]
     // CHECK-NEXT: call i8* @objc_exception_extract
     // CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[X]]
     // CHECK-NEXT: [[T2:%.*]] = add nsw i32 [[T1]], -1
 
-    // This store is dead.
-    // CHECK-NEXT: store i32 [[T2]], i32* [[X]]
-
     // CHECK: store i32 6, i32* [[X]]
     x++;
     // CHECK-NEXT: call void asm sideeffect "", "*m,*m"(i32* nonnull [[X]]
     // CHECK-NEXT: call void @foo()
     // CHECK-NEXT: call void @objc_exception_try_exit
     // CHECK-NEXT: [[T:%.*]] = load i32, i32* [[X]]
     foo();
   } @catch (id) {

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

EnablePartialOverwriteTracking("enable-dse-partial-overwrite-tracking",
   cl::desc("Enable partial-overwrite tracking in DSE"));
 
 static cl::opt<bool>
 EnablePartialStoreMerging("enable-dse-partial-store-merging",
   cl::init(true), cl::Hidden,
   cl::desc("Enable partial store merging in DSE"));
 
 static cl::opt<bool>
-    EnableMemorySSA("enable-dse-memoryssa", cl::init(false), cl::Hidden,
+    EnableMemorySSA("enable-dse-memoryssa", cl::init(true), cl::Hidden,
                     cl::desc("Use the new MemorySSA-backed DSE."));
 
 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(90), cl::Hidden,
     cl::desc("The maximum number of steps while walking upwards to find "
              "MemoryDefs that may be killed (default = 90)"));
 
 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 "

 /// we delete this instruction?
 static bool isRemovable(Instruction *I) {
   // Don't remove volatile/atomic stores.
   if (StoreInst *SI = dyn_cast<StoreInst>(I))
     return SI->isUnordered();
 
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     switch (II->getIntrinsicID()) {
     default: llvm_unreachable("doesn't pass 'hasAnalyzableMemoryWrite' predicate");
     case Intrinsic::lifetime_end:
       // Never remove dead lifetime_end's, e.g. because it is followed by a
       // free.
       return false;
     case Intrinsic::init_trampoline:
       // Always safe to remove init_trampoline.
       return true;
     case Intrinsic::memset:

llvm/test/Analysis/BasicAA/modref.ll

 define void @test3a(i8* %P, i8 %X) {
 ; CHECK-LABEL: @test3a
   %Y = add i8 %X, 1     ;; Dead, because the only use (the store) is dead.
 
   %P2 = getelementptr i8, i8* %P, i32 2
   store i8 %Y, i8* %P2
   call void @llvm.lifetime.end.p0i8(i64 10, i8* %P)
   ret void
+; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 10, i8* %P)
 ; CHECK-NEXT: ret void
 }
 
 @G1 = external global i32
 @G2 = external global [4000 x i32]
 
 define i32 @test4(i8* %P) {
   %tmp = load i32, i32* @G1

llvm/test/CodeGen/AMDGPU/opt-pipeline.ll

 ; GCN-O2-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O2-NEXT:       Optimization Remark Emitter
 ; GCN-O2-NEXT:       Combine redundant instructions
 ; GCN-O2-NEXT:       Lazy Value Information Analysis
 ; GCN-O2-NEXT:       Jump Threading
 ; GCN-O2-NEXT:       Value Propagation
 ; GCN-O2-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O2-NEXT:       Function Alias Analysis Results
-; GCN-O2-NEXT:       Phi Values Analysis
-; GCN-O2-NEXT:       Memory Dependence Analysis
-; GCN-O2-NEXT:       Dead Store Elimination
-; GCN-O2-NEXT:       Function Alias Analysis Results
+; GCN-O2-NEXT:       Post-Dominator Tree Construction
 ; GCN-O2-NEXT:       Memory SSA
+; GCN-O2-NEXT:       Dead Store Elimination
 ; GCN-O2-NEXT:       Natural Loop Information
 ; GCN-O2-NEXT:       Canonicalize natural loops
 ; GCN-O2-NEXT:       LCSSA Verifier
 ; GCN-O2-NEXT:       Loop-Closed SSA Form Pass
+; GCN-O2-NEXT:       Function Alias Analysis Results
 ; GCN-O2-NEXT:       Scalar Evolution Analysis
 ; GCN-O2-NEXT:       Loop Pass Manager
 ; GCN-O2-NEXT:         Loop Invariant Code Motion
 ; GCN-O2-NEXT:       Post-Dominator Tree Construction
 ; GCN-O2-NEXT:       Aggressive Dead Code Elimination
 ; GCN-O2-NEXT:       Simplify the CFG
 ; GCN-O2-NEXT:       Dominator Tree Construction
 ; GCN-O2-NEXT:       Basic Alias Analysis (stateless AA impl)

 ; GCN-O3-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O3-NEXT:       Optimization Remark Emitter
 ; GCN-O3-NEXT:       Combine redundant instructions
 ; GCN-O3-NEXT:       Lazy Value Information Analysis
 ; GCN-O3-NEXT:       Jump Threading
 ; GCN-O3-NEXT:       Value Propagation
 ; GCN-O3-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O3-NEXT:       Function Alias Analysis Results
-; GCN-O3-NEXT:       Phi Values Analysis
-; GCN-O3-NEXT:       Memory Dependence Analysis
-; GCN-O3-NEXT:       Dead Store Elimination
-; GCN-O3-NEXT:       Function Alias Analysis Results
+; GCN-O3-NEXT:       Post-Dominator Tree Construction
 ; GCN-O3-NEXT:       Memory SSA
+; GCN-O3-NEXT:       Dead Store Elimination
 ; GCN-O3-NEXT:       Natural Loop Information
 ; GCN-O3-NEXT:       Canonicalize natural loops
 ; GCN-O3-NEXT:       LCSSA Verifier
 ; GCN-O3-NEXT:       Loop-Closed SSA Form Pass
+; GCN-O3-NEXT:       Function Alias Analysis Results
 ; GCN-O3-NEXT:       Scalar Evolution Analysis
 ; GCN-O3-NEXT:       Loop Pass Manager
 ; GCN-O3-NEXT:         Loop Invariant Code Motion
 ; GCN-O3-NEXT:       Post-Dominator Tree Construction
 ; GCN-O3-NEXT:       Aggressive Dead Code Elimination
 ; GCN-O3-NEXT:       Simplify the CFG
 ; GCN-O3-NEXT:       Dominator Tree Construction
 ; GCN-O3-NEXT:       Basic Alias Analysis (stateless AA impl)

llvm/test/Other/new-pm-defaults.ll

 ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-EP-PEEPHOLE-NEXT: Running pass: NoOpFunctionPass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass
+; CHECK-O23SZ-NEXT: Running analysis: PostDominatorTreeAnalysis
 ; CHECK-O23SZ-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O23SZ-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O23SZ-NEXT: Running pass: LCSSAPass
 ; CHECK-O23SZ-NEXT: Finished llvm::Function pass manager run.
 ; CHECK-O23SZ-NEXT: Running pass: LICMPass
 ; CHECK-EP-SCALAR-LATE-NEXT: Running pass: NoOpFunctionPass
 ; CHECK-O-NEXT: Running pass: ADCEPass
-; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis
+; CHECK-O1-NEXT: Running analysis: PostDominatorTreeAnalysis
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-EP-PEEPHOLE-NEXT: Running pass: NoOpFunctionPass
 ; CHECK-O-NEXT: Finished llvm::Function pass manager run.
 ; CHECK-EP-CGSCC-LATE-NEXT: Running pass: NoOpCGSCCPass
 ; CHECK-O-NEXT: Finished CGSCC pass manager run.
 ; CHECK-O-NEXT: Finished llvm::Module pass manager run.
 ; CHECK-O-NEXT: Finished llvm::Module pass manager run.

llvm/test/Other/new-pm-lto-defaults.ll

 ; CHECK-O2-NEXT: Running pass: TailCallElimPass on foo
 ; CHECK-O2-NEXT: Finished llvm::Function pass manager run.
 ; CHECK-O2-NEXT: Running pass: PostOrderFunctionAttrsPass
 ; CHECK-O2-NEXT: Running pass: GVN on foo
 ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O2-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O2-NEXT: Running pass: MemCpyOptPass on foo
 ; CHECK-O2-NEXT: Running pass: DSEPass on foo
+; CHECK-O2-NEXT: Running analysis: MemorySSAAnalysis on foo
+; CHECK-O2-NEXT: Running analysis: PostDominatorTreeAnalysis on foo
 ; CHECK-O2-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O2-NEXT: Running pass: SimplifyCFGPass on foo
 ; CHECK-O2-NEXT: Running pass: SCCPPass on foo
 ; CHECK-O2-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O2-NEXT: Running pass: BDCEPass on foo
 ; CHECK-O2-NEXT: Running analysis: DemandedBitsAnalysis
 ; CHECK-O2-NEXT: Running pass: InstCombinePass
 ; CHECK-EP-Peephole-NEXT: Running pass: NoOpFunctionPass

llvm/test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-O-NEXT: Running pass: BDCEPass
 ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass
+; CHECK-O23SZ-NEXT: Running analysis: PostDominatorTreeAnalysis on foo
 ; CHECK-O23SZ-NEXT: Starting llvm::Function pass manager run
 ; CHECK-O23SZ-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O23SZ-NEXT: Running pass: LCSSAPass
 ; CHECK-O23SZ-NEXT: Finished llvm::Function pass manager run
 ; CHECK-O23SZ-NEXT: Running pass: LICMPass on Loop at depth 1 containing: %loop
 ; CHECK-O-NEXT: Running pass: ADCEPass
-; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis
+; CHECK-O1-NEXT: Running analysis: PostDominatorTreeAnalysis
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Finished llvm::Function pass manager run.
 ; CHECK-O-NEXT: Finished CGSCC pass manager run.
 ; CHECK-O-NEXT: Finished llvm::Module pass manager run.
 ; CHECK-O-NEXT: Finished llvm::Module pass manager run.
 ; CHECK-PRELINK-O-NEXT: Running pass: GlobalOptPass
 ; CHECK-POSTLINK-O-NEXT: Starting llvm::Module pass manager run.

llvm/test/Other/opt-O2-pipeline.ll

 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Combine redundant instructions
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
-; CHECK-NEXT:         Phi Values Analysis
-; CHECK-NEXT:         Memory Dependence Analysis
-; CHECK-NEXT:         Dead Store Elimination
-; CHECK-NEXT:         Function Alias Analysis Results
+; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Memory SSA
+; CHECK-NEXT:         Dead Store Elimination
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Canonicalize natural loops
 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
+; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Loop Invariant Code Motion
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

llvm/test/Other/opt-O3-pipeline-enable-matrix.ll

 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Combine redundant instructions
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
-; CHECK-NEXT:         Phi Values Analysis
-; CHECK-NEXT:         Memory Dependence Analysis
-; CHECK-NEXT:         Dead Store Elimination
-; CHECK-NEXT:         Function Alias Analysis Results
+; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Memory SSA
+; CHECK-NEXT:         Dead Store Elimination
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Canonicalize natural loops
 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
+; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Loop Invariant Code Motion
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

llvm/test/Other/opt-O3-pipeline.ll

 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Combine redundant instructions
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
-; CHECK-NEXT:         Phi Values Analysis
-; CHECK-NEXT:         Memory Dependence Analysis
-; CHECK-NEXT:         Dead Store Elimination
-; CHECK-NEXT:         Function Alias Analysis Results
+; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Memory SSA
+; CHECK-NEXT:         Dead Store Elimination
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Canonicalize natural loops
 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
+; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Loop Invariant Code Motion
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

llvm/test/Other/opt-Os-pipeline.ll

 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Combine redundant instructions
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
-; CHECK-NEXT:         Phi Values Analysis
-; CHECK-NEXT:         Memory Dependence Analysis
-; CHECK-NEXT:         Dead Store Elimination
-; CHECK-NEXT:         Function Alias Analysis Results
+; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Memory SSA
+; CHECK-NEXT:         Dead Store Elimination
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Canonicalize natural loops
 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
+; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Loop Invariant Code Motion
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

llvm/test/Transforms/Coroutines/ArgAddr.ll

 define i32 @main() {
 entry:
   %hdl = call i8* @f(i32 4)
   call void @llvm.coro.resume(i8* %hdl)
   call void @llvm.coro.resume(i8* %hdl)
   call void @llvm.coro.destroy(i8* %hdl)
   ret i32 0
 ; CHECK:      call void @ctor
+; CHECK-NEXT: %dec1.spill.addr.i = getelementptr inbounds i8, i8* %call.i, i64 16
+; CHECK-NEXT: bitcast i8* %dec1.spill.addr.i to i32*
+; CHECK-NEXT: store i32 4
 ; CHECK-NEXT: call void @print(i32 4)
+; CHECK-NEXT: %index.addr5.i = getelementptr inbounds i8, i8* %call.i, i64 20
+; CHECK-NEXT: bitcast i8* %index.addr5.i to i1*
+; CHECK-NEXT: store i1 false
+; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(
+; CHECK-NEXT: store i32 3
 ; CHECK-NEXT: call void @print(i32 3)
+; CHECK-NEXT: store i1 false
+; CHECK-NEXT: store i32 2
 ; CHECK-NEXT: call void @print(i32 2)
 ; CHECK:      ret i32 0
 }
 
 declare i8* @malloc(i32)
 declare void @free(i8*)
 declare void @print(i32)
 declare void @ctor(i8* nocapture readonly)

llvm/test/Transforms/Coroutines/coro-retcon.ll

 ; CHECK-NEXT:    store i32 4, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 4)
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    [[INC:%.*]] = add i32 [[LOAD]], 1
 ; CHECK-NEXT:    store i32 [[INC]], i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 [[INC]])
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4
 ; CHECK-NEXT:    [[INC:%.*]] = add i32 [[LOAD]], 1
-; CHECK-NEXT:    store i32 [[INC]], i32* [[SLOT]], align 4
 ; CHECK-NEXT:    call void @print(i32 [[INC]])
 ; CHECK-NEXT:    ret i32 0
 
 define hidden { i8*, i8* } @g(i8* %buffer, i16* %ptr) {
 entry:
   %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast ({ i8*, i8* } (i8*, i1)* @g_prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
   br label %loop

llvm/test/Transforms/DeadStoreElimination/MSSA/2011-03-25-DSEMiscompile.ll

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 ; PR9561
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
 target triple = "i386-apple-darwin9.8"
 
 @A = external global [0 x i32]
 
 declare ghccc void @Func2(i32*, i32*, i32*, i32)
 

llvm/test/Transforms/DeadStoreElimination/MSSA/2011-09-06-EndOfFunction.ll

-; RUN: opt -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -dse -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin"
 
 %"class.std::auto_ptr" = type { i32* }
 
 ; CHECK-LABEL: @_Z3foov(
 define void @_Z3foov(%"class.std::auto_ptr"* noalias nocapture sret %agg.result) uwtable ssp {

llvm/test/Transforms/DeadStoreElimination/MSSA/2011-09-06-MemCpy.ll

-; RUN: opt -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -dse -S < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.pair.162 = type { %struct.BasicBlock*, i32, [4 x i8] }
 %struct.BasicBlock = type { %struct.Value, %struct.ilist_node.24, %struct.iplist.22, %struct.Function* }
 %struct.Value = type { i32 (...)**, i8, i8, i16, %struct.Type*, %struct.Use*, %struct.StringMapEntry* }
 %struct.Type = type { %struct.LLVMContext*, i8, [3 x i8], i32, {}* }
 %struct.LLVMContext = type { %struct.LLVMContextImpl* }

llvm/test/Transforms/DeadStoreElimination/MSSA/2016-07-17-UseAfterFree.ll

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa  -S -enable-dse-partial-overwrite-tracking | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S -enable-dse-partial-overwrite-tracking | FileCheck %s
 ; PR28588
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind
 define void @_UPT_destroy(i8* nocapture %ptr) local_unnamed_addr #0 {
 entry:

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 define void @write4to7(i32* nocapture %p) {
 ; CHECK-LABEL: @write4to7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i64 1
 ; CHECK-NEXT:    [[P3:%.*]] = bitcast i32* [[ARRAYIDX0]] to i8*
 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[P3]], i64 4
 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 4 [[TMP0]], i8 0, i64 24, i1 false)

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 %struct.vec2 = type { <4 x i32>, <4 x i32> }
 %struct.vec2plusi = type { <4 x i32>, <4 x i32>, i32 }
 
 @glob1 = global %struct.vec2 zeroinitializer, align 16
 @glob2 = global %struct.vec2plusi zeroinitializer, align 16
 

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

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -enable-dse-partial-store-merging=false -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -enable-dse-partial-store-merging=false -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 ; Ensure that the dead store is deleted in this case.  It is wholely
 ; overwritten by the second store.
 define void @test1(i32 *%V) {
         %V2 = bitcast i32* %V to i8*            ; <i8*> [#uses=1]
         store i8 0, i8* %V2
         store i32 1234567, i32* %V

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s --data-layout "e" -dse -enable-dse-memoryssa -enable-dse-partial-store-merging=true -S | FileCheck --check-prefix CHECK --check-prefix CHECK-LE %s
-; RUN: opt < %s --data-layout "E" -dse -enable-dse-memoryssa -enable-dse-partial-store-merging=true -S | FileCheck --check-prefix CHECK --check-prefix CHECK-BE %s
+; RUN: opt < %s --data-layout "e" -dse -enable-dse-partial-store-merging=true -S | FileCheck --check-prefix CHECK --check-prefix CHECK-LE %s
+; RUN: opt < %s --data-layout "E" -dse -enable-dse-partial-store-merging=true -S | FileCheck --check-prefix CHECK --check-prefix CHECK-BE %s
 
 ; This test used to hit an assertion (see PR41949).
 ;
 ; Better safe than sorry, do not assume anything about the padding for the
 ; i28 store that has 32 bits as store size.
 define void @test1(i32* %p) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32

llvm/test/Transforms/DeadStoreElimination/MSSA/X86/gather-null-pointer.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -dse -S | FileCheck %s
 
 ; Both stores should be emitted because we can't tell if the gather aliases.
 
 define <4 x i32> @bar(<4 x i32> %arg, i32* %arg1) {
 ; CHECK-LABEL: @bar(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    store i32 5, i32* [[ARG1:%.*]]
 ; CHECK-NEXT:    [[TMP:%.*]] = tail call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> zeroinitializer, i8* null, <4 x i32> [[ARG:%.*]], <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, i8 1)

llvm/test/Transforms/DeadStoreElimination/MSSA/atomic-overlapping.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 %s -S | FileCheck %s
 
 target datalayout = "e-m:o-p:32:32-Fi8-i64:64-a:0:32-n32-S128"
 
 define void @widget(i8* %ptr) {
 ; CHECK-LABEL: @widget(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[PTR:%.*]], i32 4
 ; CHECK-NEXT:    [[PTR1_CAST:%.*]] = bitcast i8* [[PTR1]] to i32*

llvm/test/Transforms/DeadStoreElimination/MSSA/atomic-todo.ll

 ; XFAIL: *
-; RUN: opt -basic-aa -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -basic-aa -dse -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-macosx10.7.0"
 
 ; Sanity tests for atomic stores.
 ; Note that it turns out essentially every transformation DSE does is legal on
 ; atomic ops, just some transformations are not allowed across release-acquire pairs.
 

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -basic-aa -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -basic-aa -dse -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-macosx10.7.0"
 
 ; Sanity tests for atomic stores.
 ; Note that it turns out essentially every transformation DSE does is legal on
 ; atomic ops, just some transformations are not allowed across release-acquire pairs.
 

llvm/test/Transforms/DeadStoreElimination/MSSA/calloc-store.ll

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 declare noalias i8* @calloc(i64, i64)
 
 define i32* @test1() {
 ; CHECK-LABEL: test1
   %1 = tail call noalias i8* @calloc(i64 1, i64 4)
   %2 = bitcast i8* %1 to i32*
   ; This store is dead and should be removed

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 --check-prefixes=CHECK,DEFAULT-LIMIT %s
-; RUN: opt -S -dse -enable-dse-memoryssa -enable-dse-partial-store-merging=false -dse-memoryssa-partial-store-limit=10 < %s | FileCheck --check-prefixes=CHECK,LARGER-LIMIT %s
+; RUN: opt -S -dse -enable-dse-partial-store-merging=false < %s | FileCheck --check-prefixes=CHECK,DEFAULT-LIMIT %s
+; RUN: opt -S -dse -enable-dse-partial-store-merging=false -dse-memoryssa-partial-store-limit=10 < %s | FileCheck --check-prefixes=CHECK,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:

llvm/test/Transforms/DeadStoreElimination/MSSA/const-pointers.ll

-; RUN: opt -basic-aa -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -basic-aa -dse -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %t = type { i32 }
 
 @g = global i32 42
 
 define void @test1(%t* noalias %pp) {
   %p = getelementptr inbounds %t, %t* %pp, i32 0, i32 0

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

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S
+; RUN: opt < %s -basic-aa -dse -S
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 target triple = "i386-apple-darwin10.0"
 
 @g80 = external global i8                         ; <i8*> [#uses=3]
 
 declare signext i8 @foo(i8 signext, i8 signext) nounwind readnone ssp
 

llvm/test/Transforms/DeadStoreElimination/MSSA/cs-cs-aliasing.ll

-; RUN: opt -basic-aa -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -basic-aa -dse -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %class.basic_string = type { %"class.__gnu_cxx::__versa_string" }
 %"class.__gnu_cxx::__versa_string" = type { %"class.__gnu_cxx::__sso_string_base" }
 %"class.__gnu_cxx::__sso_string_base" = type { %"struct.__gnu_cxx::__vstring_utility<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider", i64, %union.anon }
 %"struct.__gnu_cxx::__vstring_utility<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider" = type { i8* }
 %union.anon = type { i64, [8 x i8] }

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
 ; 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
+; RUN: opt < %s -basic-aa -dse -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
+; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=1,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP1-COUNT1 %s
 
 ; Eliminates both stores in the entry block.
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=2 -S | FileCheck --check-prefix=SKIP0-COUNT2 %s
+; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=2 -S | FileCheck --check-prefix=SKIP0-COUNT2 %s
 
 ; Eliminates no stores.
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -debug-counter=dse-memoryssa-skip=2,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP2-COUNT1 %s
+; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=2,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP2-COUNT1 %s
 
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 
 define void @test(i32* noalias %P, i32* noalias %Q, i32* noalias %R) {
 ; SKIP0-COUNT1-LABEL: @test(
 ; SKIP0-COUNT1-NEXT:    store i32 1, i32* [[P:%.*]]

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

-; RUN: opt < %s -debugify -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -debugify -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare noalias i8* @malloc(i32)
 
 declare void @test_f()
 
 define i32* @test_salvage(i32 %arg) {

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

-; RUN: opt -dse -enable-dse-memoryssa -disable-output < %s
+; RUN: opt -dse -disable-output < %s
 ; test that we don't crash
 declare void @bar()
 
 define void @foo() {
 bb1:
   %memtmp3.i = alloca [21 x i8], align 1
   %0 = getelementptr inbounds [21 x i8], [21 x i8]* %memtmp3.i, i64 0, i64 0
   br label %bb3

llvm/test/Transforms/DeadStoreElimination/MSSA/fence-todo.ll

 ; XFAIL: *
 
-; RUN: opt -S -basic-aa -dse -enable-dse-memoryssa < %s | FileCheck %s
+; RUN: opt -S -basic-aa -dse < %s | FileCheck %s
 
 ; We DSE stack alloc'ed and byval locations, in the presence of fences.
 ; Fence does not make an otherwise thread local store visible.
 ; Right now the DSE in presence of fence is only done in end blocks (with no successors),
 ; but the same logic applies to other basic blocks as well.
 ; The store to %addr.i can be removed since it is a byval attribute
 define void @test3(i32* byval %addr.i) {
 ; CHECK-LABEL: @test3

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

-; RUN: opt -S -basic-aa -dse -enable-dse-memoryssa < %s | FileCheck %s
+; RUN: opt -S -basic-aa -dse < %s | FileCheck %s
 
 ; We conservative choose to prevent dead store elimination
 ; across release or stronger fences.  It's not required 
 ; (since the must still be a race on %addd.i), but
 ; it is conservatively correct.  A legal optimization
 ; could hoist the second store above the fence, and then
 ; DSE one of them.
 define void @test1(i32* %addr.i) {

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

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare void @free(i8* nocapture)
 declare noalias i8* @malloc(i64)
 
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT: bitcast

llvm/test/Transforms/DeadStoreElimination/MSSA/inst-limits.ll

-; RUN: opt -S -dse -enable-dse-memoryssa < %s | FileCheck %s
+; RUN: opt -S -dse < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; This test is not relevant for DSE with MemorySSA. Non-memory instructions
 ; are ignored anyways. The limits for the MemorySSA traversal are tested in
 ; llvm/test/Transforms/DeadStoreElimination/MSSA/memoryssa-scan-limit.ll
 
 @x = global i32 0, align 4
 

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

-; RUN: opt -S < %s -dse -enable-dse-memoryssa | FileCheck %s
+; RUN: opt -S < %s -dse | FileCheck %s
 
 declare void @llvm.sideeffect()
 
 ; Dead store elimination across a @llvm.sideeffect.
 
 ; CHECK-LABEL: dse
 ; CHECK: store
 ; CHECK-NOT: store
 define void @dse(float* %p) {
     store float 0.0, float* %p
     call void @llvm.sideeffect()
     store float 0.0, float* %p
     ret void
 }

llvm/test/Transforms/DeadStoreElimination/MSSA/invariant.start.ll

 ; Test to make sure llvm.invariant.start calls are not treated as clobbers.
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 declare {}* @llvm.invariant.start.p0i8(i64, i8* nocapture) nounwind readonly
 
 ; We cannot remove the store 1 to %p.
 ; FIXME: By the semantics of invariant.start, the store 3 to p is unreachable.
 define void @test(i8 *%p) {
   store i8 1, i8* %p, align 4
   %i = call {}* @llvm.invariant.start.p0i8(i64 1, i8* %p)

llvm/test/Transforms/DeadStoreElimination/MSSA/launder.invariant.group.ll

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 ; CHECK-LABEL: void @skipBarrier(i8* %ptr)
 define void @skipBarrier(i8* %ptr) {
 ; CHECK-NOT: store i8 42
   store i8 42, i8* %ptr
 ; CHECK: %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
   %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
 ; CHECK: store i8 43

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -inferattrs -basic-aa -dse -enable-dse-memoryssa < %s | FileCheck %s
+; RUN: opt -S -inferattrs -basic-aa -dse < %s | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i8* @strcpy(i8* %dest, i8* %src) nounwind
 define void @test1(i8* %src) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret void
 ;

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

-; RUN: opt -S -basic-aa -dse -enable-dse-memoryssa < %s | FileCheck %s
+; RUN: opt -S -basic-aa -dse < %s | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.memset.p0i8.i8(i8* nocapture, i8, i8, i1) nounwind
 
 define void @test1() {

llvm/test/Transforms/DeadStoreElimination/MSSA/mda-with-dbg-values.ll

-; RUN: opt -S -dse -enable-dse-memoryssa -dse-memoryssa-scanlimit=2 < %s | FileCheck %s
-; RUN: opt -S -strip-debug -dse -enable-dse-memoryssa -dse-memoryssa-scanlimit=2 < %s | FileCheck %s
+; RUN: opt -S -dse -dse-memoryssa-scanlimit=2 < %s | FileCheck %s
+; RUN: opt -S -strip-debug -dse -dse-memoryssa-scanlimit=2 < %s | FileCheck %s
 
 ; Test case to check that DSE gets the same result even if we have a dbg value
 ; between the memcpy.
 
 ; This test case is less relevant for the MemorySSA backed version of DSE, as
 ; debug values are not modeled in MemorySSA and are skipped regardless of the
 ; exploration limit.
 

llvm/test/Transforms/DeadStoreElimination/MSSA/memcpy-complete-overwrite.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
 ; XFAIL: *
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture, i8, i64, i32) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32) nounwind
 
 ; PR8701

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -dse -enable-dse-memoryssa < %s | FileCheck %s
+; RUN: opt -S -dse < %s | FileCheck %s
 
 declare void @llvm.memcpy.p0i8.p0i8.i8(i8* nocapture, i8* nocapture, i8, i1) nounwind
 declare void @llvm.memmove.p0i8.p0i8.i8(i8* nocapture, i8* nocapture, i8, i1) nounwind
 declare void @llvm.memset.p0i8.i8(i8* nocapture, i8, i8, i1) nounwind
 
 define void @test1() {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret void

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
-; 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
+; RUN: opt < %s -basic-aa -dse -S | FileCheck --check-prefix=NO-LIMIT %s
+; RUN: opt < %s -basic-aa -dse -dse-memoryssa-scanlimit=0 -S | FileCheck --check-prefix=LIMIT-0 %s
+; RUN: opt < %s -basic-aa -dse -dse-memoryssa-scanlimit=2 -S | FileCheck --check-prefix=LIMIT-2 %s
+; RUN: opt < %s -basic-aa -dse -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"
 
 
 define void @test2(i32* noalias %P, i32* noalias %Q, i32* noalias %R) {
 ; NO-LIMIT-LABEL: @test2(
 ; NO-LIMIT-NEXT:    br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
 ; NO-LIMIT:       bb1:

llvm/test/Transforms/DeadStoreElimination/MSSA/memset-and-memcpy.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 ; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa=false -S | FileCheck %s
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture, i8, i64, i32) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32) nounwind
 declare void @llvm.init.trampoline(i8*, i8*, i8*)
 

llvm/test/Transforms/DeadStoreElimination/MSSA/memset-missing-debugloc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the getelementptr generated when the dse pass determines that
 ; a memset can be shortened has the debugloc carried over from the memset.
 
-; RUN: opt -S -march=native -dse -enable-dse-memoryssa < %s| FileCheck %s
+; RUN: opt -S -march=native -dse < %s| FileCheck %s
 ; CHECK: bitcast [5 x i64]* %{{[a-zA-Z_][a-zA-Z0-9_]*}} to i8*, !dbg
 ; CHECK-NEXT: %{{[0-9]+}} = getelementptr inbounds i8, i8* %0, i64 32, !dbg ![[DBG:[0-9]+]]
 ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 16 %1, i8 0, i64 8, i1 false), !dbg ![[DBG:[0-9]+]]
 ; CHECK: ![[DBG]] = !DILocation(line: 2,
 
 ; The test IR is generated by running:
 ;
 ; clang Debugify_Dead_Store_Elimination.cpp -Wno-c++11-narrowing -S \

llvm/test/Transforms/DeadStoreElimination/MSSA/memset-unknown-sizes.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 -S %s | FileCheck %s
 
 declare i8* @_Znwm() local_unnamed_addr #0
 
 ; Function Attrs: argmemonly nounwind willreturn writeonly
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #1
 
 define void @test1(i1 %c) {
 ; CHECK-LABEL: @test1(

llvm/test/Transforms/DeadStoreElimination/MSSA/merge-stores-big-endian.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -dse -enable-dse-memoryssa -enable-dse-partial-store-merging -S < %s | FileCheck %s
+; RUN: opt -dse -enable-dse-partial-store-merging -S < %s | FileCheck %s
 target datalayout = "E-m:e-i64:64-i128:128-n32:64-S128"
 
 define void @byte_by_byte_replacement(i32 *%ptr) {
 ; CHECK-LABEL: @byte_by_byte_replacement(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 151653132, i32* [[PTR:%.*]]
 ; CHECK-NEXT:    ret void
 ;

llvm/test/Transforms/DeadStoreElimination/MSSA/merge-stores.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -dse -enable-dse-memoryssa -enable-dse-partial-store-merging -S < %s | FileCheck %s
+; RUN: opt -dse -enable-dse-partial-store-merging -S < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64"
 
 define void @byte_by_byte_replacement(i32 *%ptr) {
 ; CHECK-LABEL: @byte_by_byte_replacement(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 202050057, i32* [[PTR:%.*]]
 ; CHECK-NEXT:    ret void
 ;

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 declare noalias i8* @malloc(i64)
 
 declare void @foo()
 declare void @capture(i8*)
 

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 
 declare void @f()
 declare i32 @__CxxFrameHandler3(...)
 
 
 ; Make sure we do not eliminate `store i32 20, i32* %sv`. Even though it is a store
 ; to a stack object, we can read it in the landing/catchpad.

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
 
 define void @test13(i32* noalias %P) {
 ; CHECK-LABEL: @test13(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR:%.*]]

llvm/test/Transforms/DeadStoreElimination/MSSA/multiblock-malloc-free.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 declare void @unknown_func()
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
 

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 declare void @unknown_func()
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
 
 ; Tests where the pointer/object is accessible after the function returns.
 

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 
 define void @test4(i32* noalias %P) {
 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]

llvm/test/Transforms/DeadStoreElimination/MSSA/multiblock-multipath-throwing.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 declare void @readnone_may_throw() readnone
 
 declare void @use(i32 *)
 
 ; Tests where the pointer/object is accessible after the function returns.

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 declare void @use(i32 *)
 
 ; Tests where the pointer/object is accessible after the function returns.
 
 define void @accessible_after_return_1(i32* noalias %P, i1 %c1) {

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 --check-prefixes=CHECK,DEFAULT-LIMIT %s
-; RUN: opt -dse -enable-dse-memoryssa -dse-memoryssa-partial-store-limit=10 %s -S | FileCheck --check-prefixes=CHECK,LARGER-LIMIT %s
+; RUN: opt -dse %s -S | FileCheck --check-prefixes=CHECK,DEFAULT-LIMIT %s
+; RUN: opt -dse -dse-memoryssa-partial-store-limit=10 %s -S | FileCheck --check-prefixes=CHECK,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 an aggressive limit of partial overlap analysis.

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 define void @second_store_smaller_1(i32* noalias %P, i1 %c) {
 ; CHECK-LABEL: @second_store_smaller_1(
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 
 define void @test2(i32* noalias %P) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 declare void @unknown_func()
 
 define void @test6(i32* noalias %P) {
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]]
 ; CHECK-NEXT:    br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]

llvm/test/Transforms/DeadStoreElimination/MSSA/multiblock-unreachable.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 -S %s | FileCheck %s
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Make sure we do not crash when we encounter unreachable blocks while checking
 ; if all paths to DomAccess go through a killing block.
 define void @test(float* %ptr, i1 %c.1, i1 %c.2, i1 %c.3) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  bb:

llvm/test/Transforms/DeadStoreElimination/MSSA/no-targetdata.ll

-; RUN: opt -basic-aa -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -basic-aa -dse -S < %s | FileCheck %s
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 
 define void @fn(i8* nocapture %buf) #0 {
 entry:
 
 ; We would not eliminate the first memcpy with data layout, and we should not
 ; eliminate it without data layout.

llvm/test/Transforms/DeadStoreElimination/MSSA/noop-stores.ll

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture, i8, i64, i32) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32) nounwind
 declare void @llvm.init.trampoline(i8*, i8*, i8*)
 

llvm/test/Transforms/DeadStoreElimination/MSSA/operand-bundles.ll

-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
 
 declare noalias i8* @malloc(i64) "malloc-like"
 
 declare void @foo()
 declare void @bar(i8*)
 
 define void @test() {
   %obj = call i8* @malloc(i64 8)

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
 
 declare void @use(i64*)
 
 define void @test1() {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i64
 ; CHECK-NEXT:    call void @use(i64* [[A]])
 ; CHECK-NEXT:    [[PTR1:%.*]] = bitcast i64* [[A]] to i8*

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

-; RUN: opt -basic-aa -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -basic-aa -dse -S < %s | FileCheck %s
 ; PR11390
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define fastcc void @cat_domain(i8* nocapture %name, i8* nocapture %domain, i8** 
 nocapture %s) nounwind uwtable {
 entry:
   %call = tail call i64 @strlen(i8* %name) nounwind readonly

llvm/test/Transforms/DeadStoreElimination/MSSA/pr47285-not-overwritten-on-all-exit-paths.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 -S %s | FileCheck %s
 
 @b = local_unnamed_addr global i32 0, align 4
 
 ; Reduced test case for PR47285.
 
 ; `store i32 9, i32* @b` in %interesting is not killed by `store i32 23, i32* @b`
 ; in %killer, because it is not overwritten before reaching the end of the
 ; function via %bb.2 -> %no.overwrite.exit.

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -enable-knowledge-retention -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-knowledge-retention -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 define void @test1(i32* %Q, i32* %P) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[Q:%.*]], i64 4), "nonnull"(i32* [[Q]]), "align"(i32* [[Q]], i64 4) ]
 ; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[P:%.*]], i64 4), "nonnull"(i32* [[P]]), "align"(i32* [[P]], i64 4) ]
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %DEAD = load i32, i32* %Q
   store i32 %DEAD, i32* %P
   store i32 0, i32* %P
   ret void
 }

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; XFAIL: *
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 ; Remove redundant store if loaded value is in another block inside a loop.
 define i32 @test31(i1 %c, i32* %p, i32 %i) {
 ; CHECK-LABEL: @test31(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[BB1:%.*]]
 ; CHECK:       bb1:

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -S | FileCheck %s
-; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -enable-dse-memoryssa -S | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture, i8, i64, i32) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32) nounwind
 declare void @llvm.init.trampoline(i8*, i8*, i8*)
 

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -dse -enable-dse-memoryssa -stats -S 2>&1 | FileCheck %s
+; RUN: opt < %s -basic-aa -dse -stats -S 2>&1 | FileCheck %s
 
 ; REQUIRES: asserts
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 
 define void @test2(i32* noalias %P, i32* noalias %C, i1 %c) {
 ; CHECK-LABEL: @test2(

llvm/test/Transforms/DeadStoreElimination/MSSA/tail-byval.ll

-; RUN: opt -dse -enable-dse-memoryssa -S < %s | FileCheck %s
+; RUN: opt -dse -S < %s | FileCheck %s
 
 ; Don't eliminate stores to allocas before tail calls to functions that use
 ; byval. It's correct to mark calls like these as 'tail'. To implement this tail
 ; call, the backend should copy the bytes from the alloca into the argument area
 ; before clearing the stack.
 
 target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
 target triple = "i386-unknown-linux-gnu"

llvm/test/Transforms/MemCpyOpt/memcpy.ll

 define void @test3(%0* noalias sret %agg.result) nounwind  {
   %x.0 = alloca %0
   %x.01 = bitcast %0* %x.0 to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %x.01, i8* align 16 bitcast (%0* @x to i8*), i32 32, i1 false)
   %agg.result2 = bitcast %0* %agg.result to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %agg.result2, i8* align 16 %x.01, i32 32, i1 false)
   ret void
 ; CHECK-LABEL: @test3(
+; CHECK-NEXT: %x.0 = alloca
+; CHECK-NEXT: %x.01 = bitcast
 ; CHECK-NEXT: %agg.result1 = bitcast
 ; CHECK-NEXT: call void @llvm.memcpy
+; CHECK-NEXT: %agg.result2 = bitcast
 ; CHECK-NEXT: ret void
 }
 
 
 ; PR8644
 define void @test4(i8 *%P) {
   %A = alloca %1
   %a = bitcast %1* %A to i8*