[EarlyCSE] Add support for writeonly call CSE

Author: nikic

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

@@ -493,7 +493,7 @@ struct CallValue {
 
   static bool canHandle(Instruction *Inst) {
     CallInst *CI = dyn_cast<CallInst>(Inst);
-    if (!CI || !CI->onlyReadsMemory() ||
+    if (!CI || (!CI->onlyReadsMemory() && !CI->onlyWritesMemory()) ||
         // FIXME: Currently the calls which may access the thread id may
         // be considered as not accessing the memory. But this is
         // problematic for coroutines, since coroutines may resume in a
@@ -1626,14 +1626,17 @@ bool EarlyCSE::processNode(DomTreeNode *Node) {
         !(MemInst.isValid() && !MemInst.mayReadFromMemory()))
       LastStore = nullptr;
 
-    // If this is a read-only call, process it.
-    if (CallValue::canHandle(&Inst)) {
+    // If this is a read-only or write-only call, process it. Skip store
+    // MemInsts, as they will be more precisely handled lateron.
+    if (CallValue::canHandle(&Inst) &&
+        (!MemInst.isValid() || !MemInst.isStore())) {
       // If we have an available version of this call, and if it is the right
       // generation, replace this instruction.
       std::pair<Instruction *, unsigned> InVal = AvailableCalls.lookup(&Inst);
       if (InVal.first != nullptr &&
           isSameMemGeneration(InVal.second, CurrentGeneration, InVal.first,
-                              &Inst)) {
+                              &Inst) &&
+          InVal.first->mayReadFromMemory() == Inst.mayReadFromMemory()) {
         LLVM_DEBUG(dbgs() << "EarlyCSE CSE CALL: " << Inst
                           << "  to: " << *InVal.first << '\n');
         if (!DebugCounter::shouldExecute(CSECounter)) {
@@ -1651,6 +1654,11 @@ bool EarlyCSE::processNode(DomTreeNode *Node) {
         continue;
       }
 
+      // Increase memory generation for writes. Do this before inserting
+      // the call, so it has the generation after the write occurred.
+      if (Inst.mayWriteToMemory())
+        ++CurrentGeneration;
+
       // Otherwise, remember that we have this instruction.
       AvailableCalls.insert(&Inst, std::make_pair(&Inst, CurrentGeneration));
       continue;

llvm/test/Transforms/EarlyCSE/writeonly.ll

@@ -23,7 +23,6 @@ declare void @writeonly_void() memory(write)
 define void @writeonly_cse() {
 ; CHECK-LABEL: @writeonly_cse(
 ; CHECK-NEXT:    call void @writeonly_void()
-; CHECK-NEXT:    call void @writeonly_void()
 ; CHECK-NEXT:    ret void
 ;
   call void @writeonly_void()
@@ -36,7 +35,6 @@ define i32 @writeonly_cse_intervening_load(ptr %p) {
 ; CHECK-LABEL: @writeonly_cse_intervening_load(
 ; CHECK-NEXT:    call void @writeonly_void()
 ; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    call void @writeonly_void()
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
   call void @writeonly_void()
@@ -61,11 +59,16 @@ define void @writeonly_cse_intervening_store(ptr %p) {
 
 ; Can CSE, the store does not alias the writeonly call.
 define void @writeonly_cse_intervening_noalias_store(ptr noalias %p) {
-; CHECK-LABEL: @writeonly_cse_intervening_noalias_store(
-; CHECK-NEXT:    call void @writeonly_void()
-; CHECK-NEXT:    store i32 0, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    call void @writeonly_void()
-; CHECK-NEXT:    ret void
+; NO-MSSA-LABEL: @writeonly_cse_intervening_noalias_store(
+; NO-MSSA-NEXT:    call void @writeonly_void()
+; NO-MSSA-NEXT:    store i32 0, ptr [[P:%.*]], align 4
+; NO-MSSA-NEXT:    call void @writeonly_void()
+; NO-MSSA-NEXT:    ret void
+;
+; MSSA-LABEL: @writeonly_cse_intervening_noalias_store(
+; MSSA-NEXT:    call void @writeonly_void()
+; MSSA-NEXT:    store i32 0, ptr [[P:%.*]], align 4
+; MSSA-NEXT:    ret void
 ;
   call void @writeonly_void()
   store i32 0, ptr %p
@@ -93,11 +96,8 @@ define i32 @load_cse_across_writeonly(ptr %p) {
 define i32 @load_cse_across_csed_writeonly(ptr %p) {
 ; CHECK-LABEL: @load_cse_across_csed_writeonly(
 ; CHECK-NEXT:    call void @writeonly_void()
-; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    call void @writeonly_void()
-; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[P]], align 4
-; CHECK-NEXT:    [[RES:%.*]] = sub i32 [[V1]], [[V2]]
-; CHECK-NEXT:    ret i32 [[RES]]
+; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[P:%.*]], align 4
+; CHECK-NEXT:    ret i32 0
 ;
   call void @writeonly_void()
   %v1 = load i32, ptr %p
@@ -112,10 +112,8 @@ declare i32 @writeonly(ptr %p) memory(write)
 ; Can CSE writeonly calls with arg and return.
 define i32 @writeonly_ret_cse(ptr %p) {
 ; CHECK-LABEL: @writeonly_ret_cse(
-; CHECK-NEXT:    [[V1:%.*]] = call i32 @writeonly(ptr [[P:%.*]])
-; CHECK-NEXT:    [[V2:%.*]] = call i32 @writeonly(ptr [[P]])
-; CHECK-NEXT:    [[RES:%.*]] = sub i32 [[V1]], [[V2]]
-; CHECK-NEXT:    ret i32 [[RES]]
+; CHECK-NEXT:    [[V2:%.*]] = call i32 @writeonly(ptr [[P:%.*]])
+; CHECK-NEXT:    ret i32 0
 ;
   %v1 = call i32 @writeonly(ptr %p)
   %v2 = call i32 @writeonly(ptr %p)
@@ -163,6 +161,3 @@ define void @writeonly_and_readonly() {
   call void @callee() memory(read)
   ret void
 }
-;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
-; MSSA: {{.*}}
-; NO-MSSA: {{.*}}