[DSE,MemorySSA] Handle atomic stores expliclty in isReadClobber.

[fhahn]

Summary

Atomic stores are modeled as MemoryDef to model the fact that they may
not be reordered, depending on the ordering constraints.

Atomic stores that are monotonic or weaker do not limit re-ordering, so
we do not have to treat them as potential read clobbers.

Note that llvm/test/Transforms/DeadStoreElimination/MSSA/atomic.ll
already contains a set of negative test cases.

[asbirlea]

lgtm

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

bool isMemTerminator(MemoryLocation DefLoc, Instruction *MaybeTerm) {
     // object can be considered terminated.
     if (MaybeTermLoc->second)
       DefLoc = MemoryLocation(getUnderlyingObject(DefLoc.Ptr));
     return BatchAA.isMustAlias(MaybeTermLoc->first, DefLoc);
   }
 
   // Returns true if \p Use may read from \p DefLoc.
   bool isReadClobber(MemoryLocation DefLoc, Instruction *UseInst) {
+    // Monotonic or weaker atomic stores can be re-ordered and do not need to be
+    // treated as read clobber.
+    if (auto SI = dyn_cast<StoreInst>(UseInst))
+      return isStrongerThan(SI->getOrdering(), AtomicOrdering::Monotonic);
+
     if (!UseInst->mayReadFromMemory())
       return false;
 
     if (auto *CB = dyn_cast<CallBase>(UseInst))
       if (CB->onlyAccessesInaccessibleMemory())
         return false;
 
     // NOTE: For calls, the number of stores removed could be slightly improved

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

 ; CHECK-LABEL: test9
 ; CHECK-NOT: store i32 0
 ; CHECK: store i32 1
   store i32 0, i32* @x
   %x = load atomic i32, i32* @y monotonic, align 4
   store i32 1, i32* @x
   ret i32 %x
 }
-
-; DSE across monotonic store (allowed as long as the eliminated store isUnordered)
-define void @test10() {
-; CHECK-LABEL: test10
-; CHECK-NOT: store i32 0
-; CHECK: store i32 1
-  store i32 0, i32* @x
-  store atomic i32 42, i32* @y monotonic, align 4
-  store i32 1, i32* @x
-  ret void
-}

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

 ;
   %a = alloca i32
   call void @randomop(i32* %a)
   store i32 0, i32* %a, align 4
   %x = load atomic i32, i32* @x seq_cst, align 4
   ret i32 %x
 }
 
+; DSE across monotonic store (allowed as long as the eliminated store isUnordered)
+define void @test10() {
+; CHECK-LABEL: test10
+; CHECK-NOT: store i32 0
+; CHECK: store i32 1
+  store i32 0, i32* @x
+  store atomic i32 42, i32* @y monotonic, align 4
+  store i32 1, i32* @x
+  ret void
+}
+
 ; DSE across monotonic load (forbidden since the eliminated store is atomic)
 define i32 @test11() {
 ; CHECK-LABEL: @test11(
 ; CHECK-NEXT:    store atomic i32 0, i32* @x monotonic, align 4
 ; CHECK-NEXT:    [[X:%.*]] = load atomic i32, i32* @y monotonic, align 4
 ; CHECK-NEXT:    store atomic i32 1, i32* @x monotonic, align 4
 ; CHECK-NEXT:    ret i32 [[X]]
 ;