use RegionBranchOpInterface fix the bug.

Author: linuxlonelyeagle

mlir/lib/Analysis/DataFlow/LivenessAnalysis.cpp

@@ -17,7 +17,6 @@
 #include <mlir/IR/Operation.h>
 #include <mlir/IR/Value.h>
 #include <mlir/Interfaces/CallInterfaces.h>
-#include <mlir/Interfaces/LoopLikeInterface.h>
 #include <mlir/Interfaces/SideEffectInterfaces.h>
 #include <mlir/Support/LLVM.h>
 
@@ -166,6 +165,28 @@ void LivenessAnalysis::visitBranchOperand(OpOperand &operand) {
           blocks.push_back(&block);
       }
     }
+
+    // In the block of the successor block argument of RegionBranchOpInterface,
+    // there may be arguments of RegionBranchOpInterface, such as the IV of
+    // scf.forOp. Explicitly set this argument to live.
+    auto regionBranchOp = cast<RegionBranchOpInterface>(op);
+    for (size_t i = 0, e = op->getNumRegions(); i < e; ++i) {
+      SmallVector<RegionSuccessor> successors;
+      regionBranchOp.getSuccessorRegions(op->getRegion(i), successors);
+      for (RegionSuccessor successor : successors) {
+        if (successor.isParent())
+          continue;
+        auto arguments = successor.getSuccessor()->getArguments();
+        ValueRange regionInputs = successor.getSuccessorInputs();
+        for (auto argument : arguments) {
+          if (llvm::find(regionInputs, argument) == regionInputs.end()) {
+            (void)getLatticeElement(argument)->markLive();
+            LDBG() << "Marking RegionBranchOp's success argument live: "
+                   << argument;
+          }
+        }
+      }
+    }
   } else if (isa<BranchOpInterface>(op)) {
     // We cannot track all successor blocks of the branch operation(More
     // specifically, it's the successor's successor). Additionally, different
@@ -196,18 +217,6 @@ void LivenessAnalysis::visitBranchOperand(OpOperand &operand) {
           break;
         }
       }
-
-      // If the parentOp is live and it implements the LoopLiveOpInterface, then
-      // set its IV as live.
-      if (mayLive && isa<LoopLikeOpInterface>(parentOp)) {
-        auto loopOp = cast<LoopLikeOpInterface>(parentOp);
-        std::optional<SmallVector<Value>> ivs = loopOp.getLoopInductionVars();
-        if (ivs.has_value()) {
-          for (auto iv : *ivs) {
-            getLatticeElement(iv)->markLive();
-          }
-        }
-      }
     } else {
       // When the op is a `RegionBranchTerminatorOpInterface`, like an
       // `scf.condition` op or return-like, like an `scf.yield` op, its branch

mlir/test/Transforms/remove-dead-values.mlir

@@ -652,13 +652,25 @@ func.func @callee(%arg0: index, %arg1: index, %arg2: index) -> index {
 
 // -----
 
-// This test verifies that the induction variables in loops are not deleted.
+// This test verifies that the induction variables in loops are not deleted, the loop has results.
 
 // CHECK-LABEL: func @dead_value_loop_ivs
-func.func @dead_value_loop_ivs(%lb: index, %ub: index, %step: index, %b : i1) -> i1 {
+func.func @dead_value_loop_ivs_has_result(%lb: index, %ub: index, %step: index, %b: i1) -> i1 {
   %loop_ret = scf.for %iv = %lb to %ub step %step iter_args(%iter = %b) -> (i1) {
     cf.assert %b, "loop not dead"
     scf.yield %b : i1
   }
   return %loop_ret : i1
 }
+
+// -----
+
+// This test verifies that the induction variables in loops are not deleted, the loop has no results.
+
+// CHECK-LABEL: func @dead_value_loop_ivs_no_result
+func.func @dead_value_loop_ivs_no_result(%lb: index, %ub: index, %step: index, %input: memref<?xf32>, %value: f32, %pos: index) {
+  scf.for %iv = %lb to %ub step %step {
+    memref.store %value, %input[%pos] : memref<?xf32>
+  }
+  return
+}