[clang] 8726a1c - [CIR] Run SimplifyConstantLoad in the same driver as the other patterns (#238767)

via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 5 01:09:11 PST 2026


Author: Henrich Lauko
Date: 2026-11-05T10:08:56+01:00
New Revision: 8726a1c6b204b7df89924c61c4a3706b34d8b146

URL: https://github.com/llvm/llvm-project/commit/8726a1c6b204b7df89924c61c4a3706b34d8b146
DIFF: https://github.com/llvm/llvm-project/commit/8726a1c6b204b7df89924c61c4a3706b34d8b146.diff

LOG: [CIR] Run SimplifyConstantLoad in the same driver as the other patterns (#238767)

CIRSimplify ran SimplifyConstantLoad in a second greedy driver because
the pattern cached a DominanceInfo that the ternary and switch rewrites
could leave stale. That split needed a second op list, pruned of the
loads the first driver erased (llvm/llvm-project#238505 fused the two
collection walks but kept the split and the pruning), and it missed
simplifications: a load inside a ternary branch only folded in the
second driver, after the ternary pattern had already rejected that
branch as non-trivial.

This change shares one DominanceInfo between the pass and the pattern
and keeps it coherent with a listener that drops a region's cached tree
whenever its block list changes, so all patterns run in one driver over
one worklist.

Assisted-by: Claude Code (claude-fable-5-1).

Added: 
    clang/test/CIR/Transforms/simplify-load-in-ternary.cir

Modified: 
    clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp

Removed: 
    


################################################################################
diff  --git a/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp b/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp
index 01870c49f88a2..6c8902692993f 100644
--- a/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp
@@ -17,9 +17,6 @@
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/Passes.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace mlir;
@@ -36,6 +33,30 @@ namespace mlir {
 
 namespace {
 
+/// Dominance information that stays coherent while patterns rewrite the IR.
+/// DominanceInfo caches per region and never notices IR edits, so this doubles
+/// as the rewrite listener and drops a region's cached tree whenever its block
+/// list changes. Successor edits would need notifyOperationModified as well; no
+/// pattern here makes any.
+class RewriteDominanceInfo final : public RewriterBase::Listener {
+public:
+  DominanceInfo &getDominanceInfo() { return domInfo; }
+
+  void notifyBlockInserted(Block *block, Region *previous,
+                           Region::iterator previousIt) override {
+    domInfo.invalidate(block->getParent(), /*recursive=*/false);
+    if (previous)
+      domInfo.invalidate(previous, /*recursive=*/false);
+  }
+
+  void notifyBlockErased(Block *block) override {
+    domInfo.invalidate(block->getParent(), /*recursive=*/false);
+  }
+
+private:
+  DominanceInfo domInfo;
+};
+
 /// Find the `cir.store` operation that stores to the given alloca and dominates
 /// the given load operation. Dominance calculation is done through the given
 /// DominanceInfo object.
@@ -81,8 +102,9 @@ cir::StoreOp findDominatingInitOp(cir::AllocaOp alloca, cir::LoadOp load,
 ///   %1 = cir.load %0 : !cir.ptr<!s32i>
 ///
 /// All uses of the load above could be replaced with the SSA value `%init`.
-struct SimplifyConstantLoad : public OpRewritePattern<LoadOp> {
-  using OpRewritePattern<LoadOp>::OpRewritePattern;
+struct SimplifyConstantLoad final : public OpRewritePattern<LoadOp> {
+  SimplifyConstantLoad(MLIRContext *context, RewriteDominanceInfo &domInfo)
+      : OpRewritePattern(context), domInfo(domInfo) {}
 
   LogicalResult matchAndRewrite(LoadOp op,
                                 PatternRewriter &rewriter) const override {
@@ -94,7 +116,8 @@ struct SimplifyConstantLoad : public OpRewritePattern<LoadOp> {
     if (!allocaOp || !allocaOp.getConstant())
       return mlir::failure();
 
-    cir::StoreOp initStoreOp = findDominatingInitOp(allocaOp, op, domInfo);
+    cir::StoreOp initStoreOp =
+        findDominatingInitOp(allocaOp, op, domInfo.getDominanceInfo());
     if (!initStoreOp)
       return mlir::failure();
     if (initStoreOp.getIsVolatile() || initStoreOp.getMemOrder()) {
@@ -108,7 +131,7 @@ struct SimplifyConstantLoad : public OpRewritePattern<LoadOp> {
   }
 
 private:
-  mlir::DominanceInfo domInfo;
+  RewriteDominanceInfo &domInfo;
 };
 
 /// Simplify suitable ternary operations into select operations.
@@ -393,24 +416,14 @@ struct SimplifyVecSplat : public OpRewritePattern<VecSplatOp> {
 // CIRSimplifyPass
 //===----------------------------------------------------------------------===//
 
-// Phase 1 can erase loads the fused walk already collected: the greedy
-// driver folds plus drops trivially dead ops, so a load whose only user
-// folds away is gone before phase 2 runs. Track erasures to prune them.
-struct ErasedOpTracker : public RewriterBase::Listener {
-  void notifyOperationErased(Operation *op) override { erased.insert(op); }
-  DenseSet<Operation *> erased;
-};
-
 struct CIRSimplifyPass : public impl::CIRSimplifyBase<CIRSimplifyPass> {
   using CIRSimplifyBase::CIRSimplifyBase;
 
   void runOnOperation() override;
-
-private:
-  void runSimplifyConstantLoad(llvm::ArrayRef<Operation *> loadOps);
 };
 
-void populateMergeCleanupPatterns(RewritePatternSet &patterns) {
+void populateMergeCleanupPatterns(RewritePatternSet &patterns,
+                                  RewriteDominanceInfo &domInfo) {
   // clang-format off
   patterns.add<
     SimplifyTernary,
@@ -419,56 +432,30 @@ void populateMergeCleanupPatterns(RewritePatternSet &patterns) {
     SimplifyVecSplat
   >(patterns.getContext());
   // clang-format on
+  patterns.add<SimplifyConstantLoad>(patterns.getContext(), domInfo);
 }
 
 void CIRSimplifyPass::runOnOperation() {
-  // Collect rewrite patterns.
+  // Collect rewrite patterns. SimplifyConstantLoad queries dominance, so the
+  // dominance info doubles as the driver's listener to stay coherent.
+  RewriteDominanceInfo domInfo;
   RewritePatternSet patterns(&getContext());
-  populateMergeCleanupPatterns(patterns);
+  populateMergeCleanupPatterns(patterns, domInfo);
 
-  // Collect operations to apply patterns. Both op lists come from one
-  // walk: the first-phase patterns create no LoadOps (Select/Not/
-  // Constant only), so every load phase 2 could see is collected here.
+  // Collect operations to apply patterns.
   llvm::SmallVector<Operation *, 16> ops;
-  llvm::SmallVector<Operation *, 16> loadOps;
   getOperation()->walk([&](Operation *op) {
-    if (isa<TernaryOp, SelectOp, SwitchOp, VecSplatOp>(op))
+    if (isa<TernaryOp, SelectOp, SwitchOp, VecSplatOp, LoadOp>(op))
       ops.push_back(op);
-    else if (isa<LoadOp>(op))
-      loadOps.push_back(op);
   });
 
   // Apply patterns. Scope the rewrite to the body region, which encloses
   // the common ancestor the driver would otherwise search for.
-  ErasedOpTracker tracker;
   GreedyRewriteConfig config;
   config.setScope(&getOperation()->getRegion(0));
-  config.setListener(&tracker);
+  config.setListener(&domInfo);
   if (applyOpPatternsGreedily(ops, std::move(patterns), config).failed())
     signalPassFailure();
-
-  // Drop loads phase 1 erased (fold plus dead-op cleanup); the old
-  // second walk never saw them either.
-  llvm::erase_if(loadOps,
-                 [&](Operation *op) { return tracker.erased.contains(op); });
-
-  // SimplifyConstantLoad needs to query dominance information, which could be
-  // invalidated by other rewrite patterns. Thus we run it separately after
-  // other patterns have been applied.
-  runSimplifyConstantLoad(loadOps);
-}
-
-void CIRSimplifyPass::runSimplifyConstantLoad(
-    llvm::ArrayRef<Operation *> loadOps) {
-  RewritePatternSet patterns(&getContext());
-  patterns.add<SimplifyConstantLoad>(patterns.getContext());
-
-  // Scope the rewrite to the body region, which encloses the common
-  // ancestor the driver would otherwise search for.
-  GreedyRewriteConfig config;
-  config.setScope(&getOperation()->getRegion(0));
-  if (applyOpPatternsGreedily(loadOps, std::move(patterns), config).failed())
-    signalPassFailure();
 }
 
 } // namespace

diff  --git a/clang/test/CIR/Transforms/simplify-load-in-ternary.cir b/clang/test/CIR/Transforms/simplify-load-in-ternary.cir
new file mode 100644
index 0000000000000..6f14ecc0781fc
--- /dev/null
+++ b/clang/test/CIR/Transforms/simplify-load-in-ternary.cir
@@ -0,0 +1,27 @@
+// RUN: cir-opt %s -cir-simplify | FileCheck %s
+
+!s32i = !cir.int<s, 32>
+
+// The load inside the true branch folds to the stored constant, which leaves
+// a branch that only yields, so the ternary then simplifies to a select. The
+// second rewrite depends on the first, so both must run in the same driver.
+cir.func @load_in_ternary_branch(%cond: !cir.bool, %other: !s32i) -> !s32i {
+  %x = cir.alloca "x" align(4) init const : !cir.ptr<!s32i>
+  %init = cir.const #cir.int<42> : !s32i
+  cir.store %init, %x : !s32i, !cir.ptr<!s32i>
+  %r = cir.ternary(%cond, true {
+    %v = cir.load %x : !cir.ptr<!s32i>, !s32i
+    cir.yield %v : !s32i
+  }, false {
+    cir.yield %other : !s32i
+  }) : (!cir.bool) -> !s32i
+  cir.return %r : !s32i
+}
+
+// CHECK-LABEL: cir.func @load_in_ternary_branch
+// CHECK-SAME: (%[[COND:.*]]: !cir.bool, %[[OTHER:.*]]: !s32i)
+// CHECK: %[[INIT:.*]] = cir.const #cir.int<42> : !s32i
+// CHECK-NOT: cir.ternary
+// CHECK-NOT: cir.load
+// CHECK: %[[R:.*]] = cir.select if %[[COND]] then %[[INIT]] else %[[OTHER]] : (!cir.bool, !s32i, !s32i) -> !s32i
+// CHECK: cir.return %[[R]] : !s32i


        


More information about the cfe-commits mailing list