[EVM] Extend DSE to remove dead store at the end of a function.

Author: PavelKopyl

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

@@ -63,6 +63,9 @@
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
+// EVM local begin
+#include "llvm/IR/IntrinsicsEVM.h"
+// EVM local begin
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PatternMatch.h"
@@ -73,6 +76,9 @@
 #include "llvm/Support/DebugCounter.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
+// EVM local begin
+#include "llvm/TargetParser/Triple.h"
+// EVM local end
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
 #include "llvm/Transforms/Utils/BuildLibCalls.h"
 #include "llvm/Transforms/Utils/Local.h"
@@ -1801,6 +1807,29 @@ struct DSEState {
     return false;
   }
 
+  /// Verify whether there is a path from the block containing the store to a
+  /// return block, i.e., a block that does not end with 'unreachable'.
+  bool isOnPathToFunctionReturn(const MemoryDef *MaybeDeadDef) {
+    const BasicBlock *BB = MaybeDeadDef->getBlock();
+    // Handle the trivial case where the store resides in a block that ends
+    // with 'unreachable'.
+    if (isa<UnreachableInst>(BB->getTerminator()))
+      return false;
+
+    // Handle the general case by performing a depth-first traversal on the
+    // inverse control flow graph (CFG), starting from a return block and
+    // continuing until the block containing the store is reached.
+    for (const BasicBlock *R : PDT.roots()) {
+      if (isa<UnreachableInst>(R->getTerminator()))
+        continue;
+
+      for (auto I = idf_begin(R), E = idf_end(R); I != E; ++I)
+        if (*I == BB)
+          return true;
+    }
+    return false;
+  }
+
   /// Eliminate writes to objects that are not visible in the caller and are not
   /// accessed before returning from the function.
   bool eliminateDeadWritesAtEndOfFunction() {
@@ -1828,8 +1857,23 @@ struct DSEState {
         // underlying objects is very uncommon. If it turns out to be important,
         // we can use getUnderlyingObjects here instead.
         const Value *UO = getUnderlyingObject(DefLoc->Ptr);
-        if (!isInvisibleToCallerAfterRet(UO))
-          continue;
+        if (!isInvisibleToCallerAfterRet(UO)) {
+          // EVM local begin
+          // For EVM verify that all paths originating from the basic block
+          // containing the store eventually lead to blocks that terminate with
+          // an 'unreachable' instruction. If, in addition, the store is not
+          // read before the function returns (as determined by
+          // isWriteAtEndOfFunction), then the store can be safely eliminated.
+          // TODO: Evaluate this transformation across all targets
+          // (i.e., without limiting it to EVM) to assess whether it could be
+          // upstreamed. At first glance, this appears to be EVM-specific,
+          // since in the general case it is not guaranteed that memory side
+          // effects preceding an unreachable can be safely ignored.
+          Triple TT(DefI->getFunction()->getParent()->getTargetTriple());
+          if (!TT.isEVM() || isOnPathToFunctionReturn(Def))
+            continue;
+          // EVM local end
+        }
 
         if (isWriteAtEndOfFunction(Def, *DefLoc)) {
           // See through pointer-to-pointer bitcasts

llvm/test/CodeGen/EVM/evm-dse.ll

@@ -0,0 +1,55 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt -aa-pipeline=basic-aa,evm-aa -passes=dse -S < %s | FileCheck %s
+target datalayout = "E-p:256:256-i256:256:256-S256-a:256:256"
+target triple = "evm-unknown-unknown"
+
+declare i256 @llvm.evm.calldatasize()
+declare void @llvm.evm.return(ptr addrspace(1) readonly, i256)
+declare void @llvm.evm.revert(ptr addrspace(1) readonly, i256)
+declare void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) noalias nocapture writeonly, ptr addrspace(3) noalias nocapture readonly, i256, i1 immarg)
+
+; This test verifies that unused heap stores can be safely eliminated before revert or return intrinsics.
+define void @test(ptr addrspace(3) %src) noreturn {
+; CHECK-LABEL: define void @test(
+; CHECK-SAME: ptr addrspace(3) [[SRC:%.*]]) #[[ATTR3:[0-9]+]] {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    [[CALLDATASIZE:%.*]] = tail call i256 @llvm.evm.calldatasize()
+; CHECK-NEXT:    br label %[[IF_JOIN22:.*]]
+; CHECK:       [[IF_JOIN22]]:
+; CHECK-NEXT:    store i256 1, ptr addrspace(5) null, align 32
+; CHECK-NEXT:    [[COMPARISON_RESULT_I:%.*]] = icmp ugt i256 [[CALLDATASIZE]], 4
+; CHECK-NEXT:    br i1 [[COMPARISON_RESULT_I]], label %[[FUN_EXIT:.*]], label %[[IF_JOIN:.*]]
+; CHECK:       [[IF_JOIN]]:
+; CHECK-NEXT:    store i256 7, ptr addrspace(6) null, align 32
+; CHECK-NEXT:    tail call void @llvm.evm.return(ptr addrspace(1) noalias nocapture nofree noundef nonnull align 32 null, i256 32)
+; CHECK-NEXT:    unreachable
+; CHECK:       [[FUN_EXIT]]:
+; CHECK-NEXT:    store i256 2, ptr addrspace(5) null, align 32
+; CHECK-NEXT:    tail call void @llvm.evm.revert(ptr addrspace(1) noalias nocapture nofree noundef nonnull align 32 null, i256 0)
+; CHECK-NEXT:    unreachable
+;
+entry:
+  ; To be removed
+  store i256 128, ptr addrspace(1) inttoptr (i256 64 to ptr addrspace(1)), align 32
+  %calldatasize = tail call i256 @llvm.evm.calldatasize()
+  br label %if_join22
+
+if_join22:
+  store i256 1, ptr addrspace(5) null, align 32
+  %comparison_result.i = icmp ugt i256 %calldatasize, 4
+  br i1 %comparison_result.i, label %fun_exit, label %if_join
+
+if_join:
+  store i256 7, ptr addrspace(6) null, align 32
+  ; To be removed
+  call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) inttoptr (i256 128 to ptr addrspace(1)), ptr addrspace(3) %src, i256 32, i1 false)
+  tail call void @llvm.evm.return(ptr addrspace(1) noalias nocapture nofree noundef nonnull align 32 null, i256 32)
+  unreachable
+
+fun_exit:
+  ; To be removed
+  store i256 10, ptr addrspace(1) null, align 32
+  store i256 2, ptr addrspace(5) null, align 32
+  tail call void @llvm.evm.revert(ptr addrspace(1) noalias nocapture nofree noundef nonnull align 32 null, i256 0)
+  unreachable
+}