[mlir] GreedyPatternRewriteDriver: Do not CSE or hoist constants

[springerm]

Summary

Instead, constants are CSE'd and hoisted in the canonicalizer pass, unless cse-constants = false. (Alternatively, the CSE pass also CSE's constants.)

The purpose of this change is to simplify the greedy pattern rewriter and to make it less surprising.

Note: This change may cause constants to be reordered. But we also do not care about other ops being reordered.

[springerm]

Note: There is a crash in a Shape dialect test case that I have not fixed yet.

[mehdi_amini]

The motivation for this change isn't obvious to me from the description, can you elaborate a bit more?

[springerm]

In D142908#4092302, @mehdi_amini wrote:

The motivation for this change isn't obvious to me from the description, can you elaborate a bit more?

This is originally coming from a use case in IREE: We have a dispatch.region op that models a fusion group. The op is not isolated from above. (It will be converted to an "isolated-from-above" variant later in the lowering process.) Ops are moved into the region of the fusion group one-by-one according to some heuristic. (That's just easier to do when the op is not isolated from above yet.) We occasionally want to run a fix point iteration of a few small rewrite patterns to resolve some dynamic shapes; none of these patterns do anything with constants. We can't use the greedy pattern rewriter for that because it hoists constants from the fusion group.

That's just one small use case in a downstream project though. The more important question for me was: Should the GreedyPatternRewriteDriver CSE and hoist constant ops, when its name suggests that it merely applies rewrite patterns and foldings? Especially since we have a dedicated CSE pass for things like that.

Based on the code comments, the reason for this functionality was to prevent constants from being reordered (and not to specifically CSE/hoist constants). I think it's not really a problem in practice -- the number of affected tests is pretty small and users are encouraged to use CHECK-DAG in their tests anyway.

[mehdi_amini]

In D142908#4092762, @springerm wrote:

In D142908#4092302, @mehdi_amini wrote:

The motivation for this change isn't obvious to me from the description, can you elaborate a bit more?

This is originally coming from a use case in IREE: We have a dispatch.region op that models a fusion group. The op is not isolated from above. (It will be converted to an "isolated-from-above" variant later in the lowering process.) Ops are moved into the region of the fusion group one-by-one according to some heuristic. (That's just easier to do when the op is not isolated from above yet.) We occasionally want to run a fix point iteration of a few small rewrite patterns to resolve some dynamic shapes; none of these patterns do anything with constants. We can't use the greedy pattern rewriter for that because it hoists constants from the fusion group.

I've seen this in the past, but I generally apply a "sink constant" pass afterward to rematerialize constant in dispatched regions.
That said, shouldn't the "scope" mechanism of the driver be enough to support this? That is: we shouldn't hoist constant outside of the provided scope maybe?

That's just one small use case in a downstream project though. The more important question for me was: Should the GreedyPatternRewriteDriver CSE and hoist constant ops, when its name suggests that it merely applies rewrite patterns and foldings? Especially since we have a dedicated CSE pass for things like that.

It depends: it this is "free" and helps with canonicalization, I can see this being something we want to be intertwined in the driver, otherwise we may hit some "pass ordering" issue.

Based on the code comments, the reason for this functionality was to prevent constants from being reordered (and not to specifically CSE/hoist constants). I think it's not really a problem in practice -- the number of affected tests is pretty small and users are encouraged to use CHECK-DAG in their tests anyway.

The order of constant in the absolute may not be a problem, but we really would want canonicalized to stay idempotent.

For anyone tagging along on this review, seems like it comes from: https://reviews.llvm.org/D122692 and https://github.com/llvm/llvm-project/issues/51892

[mehdi_amini]

Based on the code comments, the reason for this functionality was to prevent constants from being reordered (and not to specifically CSE/hoist constants). I think it's not really a problem in practice -- the number of affected tests is pretty small and users are encouraged to use CHECK-DAG in their tests anyway.

The order of constant in the absolute may not be a problem, but we really would want canonicalized to stay idempotent.

For anyone tagging along on this review, seems like it comes from: https://reviews.llvm.org/D122692 and https://github.com/llvm/llvm-project/issues/51892

This background is worth adding to the description by the way.

[springerm]

Looking at https://reviews.llvm.org/D122692, there seem to be legitimate reasons for preserving the op order. I'll see if I can preserve this part without CSE'ing/hoisting constants.

That said, shouldn't the "scope" mechanism of the driver be enough to support this?

In this particular use case, the region ops themselves are part of the rewrite, so the scope is actually the entire function.

That is: we shouldn't hoist constant outside of the provided scope maybe?

That should already be the case. The OperationFolder never sees any ops/constants that are out of scope, so it shouldn't CSE with those.

I've seen this in the past, but I generally apply a "sink constant" pass afterward to rematerialize constant in dispatched regions.

That should work.

mlir/include/mlir/Transforms/Passes.td

let description = [{
     loaded dialects until either a fixpoint is reached or the maximum number of
     iterations/rewrites is exhausted. Canonicalization is best-effort and does
     not guarantee that the entire IR is in a canonical form after running this
     pass. See [Operation Canonicalization](Canonicalization.md) for more
     details.
   }];
   let constructor = "mlir::createCanonicalizerPass()";
   let options = [
+    Option<"cseConstants", "cse-constants", "bool", /*default=*/"true",
+           "Deduplicate and potentially hoist constants">,
     Option<"topDownProcessingEnabled", "top-down", "bool",
            /*default=*/"true",
            "Seed the worklist in general top-down order">,
     Option<"enableRegionSimplification", "region-simplify", "bool",
            /*default=*/"true",
            "Perform control flow optimizations to the region tree">,
     Option<"maxIterations", "max-iterations", "int64_t",
            /*default=*/"10",

mlir/lib/Transforms/Canonicalizer.cpp

 //===- Canonicalizer.cpp - Canonicalize MLIR operations -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass converts operations into their canonical forms by
 // folding constants, applying operation identity transformations etc.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Passes.h"
 
+#include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CANONICALIZER
 #include "mlir/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
void runOnOperation() override {
     config.enableRegionSimplification = enableRegionSimplification;
     config.maxIterations = maxIterations;
     config.maxNumRewrites = maxNumRewrites;
     LogicalResult converged =
         applyPatternsAndFoldGreedily(getOperation(), patterns, config);
     // Canonicalization is best-effort. Non-convergence is not a pass failure.
     if (testConvergence && failed(converged))
       signalPassFailure();
+
+    if (this->cseConstants) {
+      OperationFolder folder(getOperation()->getContext());
+      getOperation()->walk([&](Operation *op) {
+        Attribute constValue;
+        if (matchPattern(op, m_Constant(&constValue)))
+          (void)folder.insertKnownConstant(op, constValue);
+      });
+    }
   }
 
   FrozenRewritePatternSet patterns;
 };
 } // namespace
 
 /// Create a Canonicalizer pass.
 std::unique_ptr<Pass> mlir::createCanonicalizerPass() {

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

 //===- GreedyPatternRewriteDriver.cpp - A greedy rewriter -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements mlir::applyPatternsAndFoldGreedily.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-#include "mlir/IR/Matchers.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Rewrite/PatternApplicator.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/CommandLine.h"
RegionPatternRewriteDriver::RegionPatternRewriteDriver(
     : GreedyPatternRewriteDriver(ctx, patterns, config), region(region) {
   // Populate strict mode ops.
   if (config.strictMode != GreedyRewriteStrictness::AnyOp) {
     region.walk([&](Operation *op) { strictModeFilteredOps.insert(op); });
   }
 }
 
 LogicalResult RegionPatternRewriteDriver::simplify() && {
-  auto insertKnownConstant = [&](Operation *op) {
-    // Check for existing constants when populating the worklist. This avoids
-    // accidentally reversing the constant order during processing.
-    Attribute constValue;
-    if (matchPattern(op, m_Constant(&constValue)))
-      if (!folder.insertKnownConstant(op, constValue))
-        return true;
-    return false;
-  };
-
   bool changed = false;
   int64_t iteration = 0;
   do {
     // Check if the iteration limit was reached.
     if (iteration++ >= config.maxIterations &&
         config.maxIterations != GreedyRewriteConfig::kNoLimit)
       break;
 
     worklist.clear();
     worklistMap.clear();
 
     if (!config.useTopDownTraversal) {
       // Add operations to the worklist in postorder.
       region.walk([&](Operation *op) {
-        if (!insertKnownConstant(op))
-          addToWorklist(op);
       });
     } else {
       // Add all nested operations to the worklist in preorder.
       region.walk<WalkOrder::PreOrder>([&](Operation *op) {
-        if (!insertKnownConstant(op)) {
-          worklist.push_back(op);
-          return WalkResult::advance();
-        }
-        return WalkResult::skip();
       });
 
       // Reverse the list so our pop-back loop processes them in-order.
       std::reverse(worklist.begin(), worklist.end());
       // Remember the reverse index.
       for (size_t i = 0, e = worklist.size(); i != e; ++i)
         worklistMap[worklist[i]] = i;
     }

mlir/test/Dialect/GPU/transform-gpu.mlir

 // CHECK-SAME:    %[[ARGX:[0-9a-z]+]]: memref<2x32xf32>
 // CHECK-SAME:    %[[ARGY:[0-9a-z]+]]: memref<2x32xf32>
 // CHECK-SAME:    %[[ARGT:[0-9a-z]+]]: memref<32xf32>
 func.func @saxpy2d(%x: !type, %y: !type, %t: !type1d, %alpha : f32, %stream : !gpu.async.token) -> !type {
   %one = arith.constant 1 : index
   %c12 = arith.constant 12 : index
   %c9 = arith.constant 9 : index
   %c7 = arith.constant 7 : index
-//      CHECK:   %[[C1:.*]] = arith.constant 1 : index
-//      CHECK:   %[[C12:.*]] = arith.constant 12 : index
-//      CHECK:   %[[C9:.*]] = arith.constant 9 : index
-//      CHECK:   %[[C7:.*]] = arith.constant 7 : index
+//  CHECK-DAG:   %[[C1:.*]] = arith.constant 1 : index
+//  CHECK-DAG:   %[[C12:.*]] = arith.constant 12 : index
+//  CHECK-DAG:   %[[C9:.*]] = arith.constant 9 : index
+//  CHECK-DAG:   %[[C7:.*]] = arith.constant 7 : index
 //      CHECK:   gpu.launch async [%{{.*}}] blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %[[C1]], %{{.*}} = %[[C1]], %{{.*}} = %[[C1]]) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %[[C12]], %{{.*}} = %[[C9]], %{{.*}} = %[[C1]])
 //      CHECK:   %[[TIDX:.*]] = gpu.thread_id  x
 //      CHECK:   %[[TIDY:.*]] = gpu.thread_id  y
 //      CHECK:   arith.cmpi ult, %[[TIDX]], %[[C9]] : index
 //      CHECK:   arith.cmpi ult, %[[TIDY]], %[[C7]] : index
 //      CHECK:   memref.load %[[ARGX]][%[[TIDY]], %[[TIDX]]]
 //      CHECK:   memref.load %[[ARGY]][%[[TIDY]], %[[TIDX]]]
 //      CHECK:   gpu.barrier

 
 // CHECK-LABEL: func.func @saxpy4d(
 // CHECK-SAME:    %[[ARGX:[0-9a-z]+]]: memref<32x64x4x32xf32>
 // CHECK-SAME:    %[[ARGY:[0-9a-z]+]]: memref<32x64x4x32xf32>
 func.func @saxpy4d(%x: !type4d, %y: !type4d, %alpha : f32) -> !type4d {
   %c32 = arith.constant 32 : index
   %c64 = arith.constant 64 : index
   %c4 = arith.constant 4 : index
-//      CHECK:   %[[C32:.*]] = arith.constant 32 : index
-//      CHECK:   %[[C64:.*]] = arith.constant 64 : index
-//      CHECK:   %[[C4:.*]] = arith.constant 4 : index
-//      CHECK:   %[[C1:.*]] = arith.constant 1 : index
+//  CHECK-DAG:   %[[C32:.*]] = arith.constant 32 : index
+//  CHECK-DAG:   %[[C64:.*]] = arith.constant 64 : index
+//  CHECK-DAG:   %[[C4:.*]] = arith.constant 4 : index
+//  CHECK-DAG:   %[[C1:.*]] = arith.constant 1 : index
 //      CHECK:   gpu.launch blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %[[C32]], %{{.*}} = %[[C64]], %{{.*}} = %[[C1]]) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %[[C32]], %{{.*}} = %[[C4]], %{{.*}} = %[[C1]])
 //      CHECK:   %[[BLKX:.*]] = gpu.block_id  x
 //      CHECK:   %[[BLKY:.*]] = gpu.block_id  y
 //      CHECK:   %[[TIDX:.*]] = gpu.thread_id  x
 //      CHECK:   %[[TIDY:.*]] = gpu.thread_id  y
 //      CHECK:   memref.load %[[ARGX]][%[[BLKX]], %[[BLKY]], %[[TIDY]], %[[TIDX]]]
 //      CHECK:   memref.load %[[ARGY]][%[[BLKX]], %[[BLKY]], %[[TIDY]], %[[TIDX]]]
   scf.foreach_thread (%i, %j) in (%c32, %c64) {

mlir/test/Dialect/MemRef/canonicalize.mlir

func.func @subview_negative_stride1(%arg0 : memref<?xf32>) -> memref<?xf32, strided<[?], offset: ?>>
   %c1 = arith.constant -1 : index
   %1 = memref.dim %arg0, %c0 : memref<?xf32>
   %2 = arith.addi %1, %c1 : index
   %3 = memref.subview %arg0[%2] [%1] [%c1] : memref<?xf32> to memref<?xf32, strided<[?], offset: ?>>
   return %3 : memref<?xf32, strided<[?], offset: ?>>
 }
 //       CHECK: func @subview_negative_stride1
 //  CHECK-SAME:   (%[[ARG0:.*]]: memref<?xf32>)
-//       CHECK:   %[[C1:.*]] = arith.constant 0
-//       CHECK:   %[[C2:.*]] = arith.constant -1
+//   CHECK-DAG:   %[[C1:.*]] = arith.constant 0
+//   CHECK-DAG:   %[[C2:.*]] = arith.constant -1
 //       CHECK:   %[[DIM1:.*]] = memref.dim %[[ARG0]], %[[C1]] : memref<?xf32>
 //       CHECK:   %[[DIM2:.*]] = arith.addi %[[DIM1]], %[[C2]] : index
 //       CHECK:   %[[RES1:.*]] = memref.subview %[[ARG0]][%[[DIM2]]] [%[[DIM1]]] [-1] : memref<?xf32> to memref<?xf32, strided<[-1], offset: ?>>
 //       CHECK:   %[[RES2:.*]] = memref.cast %[[RES1]] : memref<?xf32, strided<[-1], offset: ?>> to memref<?xf32, strided<[?], offset: ?>>
 //       CHECK:   return %[[RES2]] : memref<?xf32, strided<[?], offset: ?>>
 
 // -----
 

mlir/test/Dialect/SCF/canonicalize.mlir

func.func @invariant_loop_args_in_same_order(%f_arg0: tensor<i32>) -> (tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>) {
   ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>, %arg4: tensor<i32>): // no predecessors
     // %arg1 here will get replaced by %cst_1
     %1 = arith.addi %arg0, %arg1 : tensor<i32>
     %2 = arith.addi %arg2, %arg3 : tensor<i32>
     scf.yield %1, %arg1, %2, %2, %arg4 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
   }
   return %0#0, %0#1, %0#2, %0#3, %0#4 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
 }
-// CHECK:    %[[ZERO:.*]] = arith.constant dense<0>
-// CHECK:    %[[ONE:.*]] = arith.constant dense<1>
-// CHECK:    %[[CST42:.*]] = arith.constant dense<42>
-// CHECK:    %[[WHILE:.*]]:3 = scf.while (%[[ARG0:.*]] = %[[ZERO]], %[[ARG2:.*]] = %[[ONE]], %[[ARG3:.*]] = %[[ONE]])
-// CHECK:       arith.cmpi slt, %[[ARG0]], %{{.*}}
-// CHECK:       tensor.extract %{{.*}}[]
-// CHECK:       scf.condition(%{{.*}}) %[[ARG0]], %[[ARG2]], %[[ARG3]]
-// CHECK:    } do {
-// CHECK:     ^{{.*}}(%[[ARG0:.*]]: tensor<i32>, %[[ARG2:.*]]: tensor<i32>, %[[ARG3:.*]]: tensor<i32>):
-// CHECK:       %[[VAL0:.*]] = arith.addi %[[ARG0]], %[[FUNC_ARG0]]
-// CHECK:       %[[VAL1:.*]] = arith.addi %[[ARG2]], %[[ARG3]]
-// CHECK:       scf.yield %[[VAL0]], %[[VAL1]], %[[VAL1]]
-// CHECK:    }
-// CHECK:    return %[[WHILE]]#0, %[[FUNC_ARG0]], %[[WHILE]]#1, %[[WHILE]]#2, %[[ZERO]]
+// CHECK-DAG: %[[ZERO:.*]] = arith.constant dense<0>
+// CHECK-DAG: %[[ONE:.*]] = arith.constant dense<1>
+// CHECK-DAG: %[[CST42:.*]] = arith.constant dense<42>
+// CHECK:     %[[WHILE:.*]]:3 = scf.while (%[[ARG0:.*]] = %[[ZERO]], %[[ARG2:.*]] = %[[ONE]], %[[ARG3:.*]] = %[[ONE]])
+// CHECK:        arith.cmpi slt, %[[ARG0]], %{{.*}}
+// CHECK:        tensor.extract %{{.*}}[]
+// CHECK:        scf.condition(%{{.*}}) %[[ARG0]], %[[ARG2]], %[[ARG3]]
+// CHECK:     } do {
+// CHECK:      ^{{.*}}(%[[ARG0:.*]]: tensor<i32>, %[[ARG2:.*]]: tensor<i32>, %[[ARG3:.*]]: tensor<i32>):
+// CHECK:        %[[VAL0:.*]] = arith.addi %[[ARG0]], %[[FUNC_ARG0]]
+// CHECK:        %[[VAL1:.*]] = arith.addi %[[ARG2]], %[[ARG3]]
+// CHECK:        scf.yield %[[VAL0]], %[[VAL1]], %[[VAL1]]
+// CHECK:     }
+// CHECK:     return %[[WHILE]]#0, %[[FUNC_ARG0]], %[[WHILE]]#1, %[[WHILE]]#2, %[[ZERO]]
 
 // CHECK-LABEL: @while_loop_invariant_argument_different_order
 func.func @while_loop_invariant_argument_different_order() -> (tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>) {
   %cst_0 = arith.constant dense<0> : tensor<i32>
   %cst_1 = arith.constant dense<1> : tensor<i32>
   %cst_42 = arith.constant dense<42> : tensor<i32>
 
   %0:6 = scf.while (%arg0 = %cst_0, %arg1 = %cst_1, %arg2 = %cst_1, %arg3 = %cst_1, %arg4 = %cst_0) : (tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>) {
     %1 = arith.cmpi slt, %arg0, %cst_42 : tensor<i32>
     %2 = tensor.extract %1[] : tensor<i1>
     scf.condition(%2) %arg1, %arg0, %arg2, %arg0, %arg3, %arg4 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
   } do {
   ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>, %arg4: tensor<i32>, %arg5: tensor<i32>): // no predecessors
     %1 = arith.addi %arg0, %cst_1 : tensor<i32>
     %2 = arith.addi %arg2, %arg3 : tensor<i32>
     scf.yield %arg3, %arg1, %2, %2, %arg4 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
   }
   return %0#0, %0#1, %0#2, %0#3, %0#4, %0#5 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
 }
-// CHECK:    %[[ZERO:.*]] = arith.constant dense<0>
-// CHECK:    %[[ONE:.*]] = arith.constant dense<1>
-// CHECK:    %[[CST42:.*]] = arith.constant dense<42>
-// CHECK:    %[[WHILE:.*]]:2 = scf.while (%[[ARG1:.*]] = %[[ONE]], %[[ARG4:.*]] = %[[ZERO]])
-// CHECK:       arith.cmpi slt, %[[ZERO]], %[[CST42]]
-// CHECK:       tensor.extract %{{.*}}[]
-// CHECK:       scf.condition(%{{.*}}) %[[ARG1]], %[[ARG4]]
-// CHECK:    } do {
-// CHECK:     ^{{.*}}(%{{.*}}: tensor<i32>, %{{.*}}: tensor<i32>):
-// CHECK:       scf.yield %[[ZERO]], %[[ONE]]
-// CHECK:    }
-// CHECK:    return %[[WHILE]]#0, %[[ZERO]], %[[ONE]], %[[ZERO]], %[[ONE]], %[[WHILE]]#1
+// CHECK-DAG: %[[ZERO:.*]] = arith.constant dense<0>
+// CHECK-DAG: %[[ONE:.*]] = arith.constant dense<1>
+// CHECK-DAG: %[[CST42:.*]] = arith.constant dense<42>
+// CHECK:     %[[WHILE:.*]]:2 = scf.while (%[[ARG1:.*]] = %[[ONE]], %[[ARG4:.*]] = %[[ZERO]])
+// CHECK:        arith.cmpi slt, %[[ZERO]], %[[CST42]]
+// CHECK:        tensor.extract %{{.*}}[]
+// CHECK:        scf.condition(%{{.*}}) %[[ARG1]], %[[ARG4]]
+// CHECK:     } do {
+// CHECK:      ^{{.*}}(%{{.*}}: tensor<i32>, %{{.*}}: tensor<i32>):
+// CHECK:        scf.yield %[[ZERO]], %[[ONE]]
+// CHECK:     }
+// CHECK:     return %[[WHILE]]#0, %[[ZERO]], %[[ONE]], %[[ZERO]], %[[ONE]], %[[WHILE]]#1
 
 // -----
 
 // CHECK-LABEL: @while_unused_result
 func.func @while_unused_result() -> i32 {
   %0:2 = scf.while () : () -> (i32, i64) {
     %condition = "test.condition"() : () -> i1
     %v1 = "test.get_some_value"() : () -> i32

mlir/test/Dialect/SCF/loop-pipelining.mlir

%r = scf.for %i0 = %c0 to %c4 step %c1 iter_args(%arg0 = %cf) -> (f32) {
     scf.yield %A2_elem : f32
   }  { __test_pipelining_loop__ }
   return %r : f32
 }
 
 // -----
 
 // CHECK: @pipeline_op_with_region(%[[ARG0:.+]]: memref<?xf32>, %[[ARG1:.+]]: memref<?xf32>, %[[ARG2:.+]]: memref<?xf32>, %[[CF:.*]]: f32) {
-// CHECK:   %[[C0:.+]] = arith.constant 0 :
-// CHECK:   %[[C3:.+]] = arith.constant 3 :
-// CHECK:   %[[C1:.+]] = arith.constant 1 :
-// CHECK:   %[[APRO:.+]] = memref.alloc() :
-// CHECK:   %[[BPRO:.+]] = memref.alloc() :
-// CHECK:   %[[ASV0:.+]] = memref.subview %[[ARG0]][%[[C0]]] [8] [1] :
-// CHECK:   %[[BSV0:.+]] = memref.subview %[[ARG1]][%[[C0]]] [8] [1] :
+// CHECK-DAG: %[[C0:.+]] = arith.constant 0 :
+// CHECK-DAG: %[[C3:.+]] = arith.constant 3 :
+// CHECK-DAG: %[[C1:.+]] = arith.constant 1 :
+// CHECK:     %[[APRO:.+]] = memref.alloc() :
+// CHECK:     %[[BPRO:.+]] = memref.alloc() :
+// CHECK:     %[[ASV0:.+]] = memref.subview %[[ARG0]][%[[C0]]] [8] [1] :
+// CHECK:     %[[BSV0:.+]] = memref.subview %[[ARG1]][%[[C0]]] [8] [1] :
 
 // Prologue:
 // CHECK:   %[[PAV0:.+]] = memref.subview %[[APRO]][%[[C0]], 0] [1, 8] [1, 1] :
 // CHECK:   %[[PBV0:.+]] = memref.subview %[[BPRO]][%[[C0]], 0] [1, 8] [1, 1] :
 // CHECK:   memref.copy %[[ASV0]], %[[PAV0]] :
 // CHECK:   memref.copy %[[BSV0]], %[[PBV0]] :
 
 // Kernel:

mlir/test/Dialect/SparseTensor/buffer_rewriting.mlir

 // CHECK:         }
 
 // CHECK-LABEL:   func.func private @_sparse_partition_1_i8_f32_index(
 // CHECK-SAME:                                                        %[[L:arg0]]: index,
 // CHECK-SAME:                                                        %[[H:.*]]: index,
 // CHECK-SAME:                                                        %[[X0:.*]]: memref<?xi8>,
 // CHECK-SAME:                                                        %[[Y0:.*]]: memref<?xf32>,
 // CHECK-SAME:                                                        %[[Y1:.*]]: memref<?xindex>) -> index {
-// CHECK:           %[[C1:.*]] = arith.constant 1
-// CHECK:           %[[VAL_6:.*]] = arith.constant -
+// CHECK-DAG:       %[[C1:.*]] = arith.constant 1
+// CHECK-DAG:       %[[VAL_6:.*]] = arith.constant -
 // CHECK:           %[[SUM:.*]] = arith.addi %[[L]], %[[H]]
 // CHECK:           %[[P:.*]] = arith.shrui %[[SUM]], %[[C1]]
 // CHECK:           %[[J:.*]] = arith.subi %[[H]], %[[C1]]
 // CHECK:           %[[W:.*]]:3 = scf.while (%[[Ib:.*]] = %[[L]], %[[Jb:.*]] = %[[J]], %[[pb:.*]] = %[[P]]) : (index, index, index) -> (index, index, index) {
 // CHECK:             %[[Cn:.*]] = arith.cmpi ult, %[[Ib]], %[[Jb]]
 // CHECK:             scf.condition(%[[Cn]]) %[[Ib]], %[[Jb]], %[[pb]]
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[Ia:.*]]: index, %[[Ja:.*]]: index, %[[Pa:.*]]: index):

mlir/test/Dialect/SparseTensor/codegen.mlir

 //       CHECK: return
 func.func @sparse_dealloc_csr(%arg0: tensor<?x?xf64, #CSR>) {
   bufferization.dealloc_tensor %arg0 : tensor<?x?xf64, #CSR>
   return
 }
 
 // CHECK-LABEL:   func.func @sparse_alloc_csc(
 //  CHECK-SAME:     %[[A0:.*]]: index) -> (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
-//       CHECK:     %[[A1:.*]] = arith.constant 10 : i64
-//       CHECK:     %[[A2:.*]] = arith.constant 0 : index
+//   CHECK-DAG:     %[[A1:.*]] = arith.constant 10 : i64
+//   CHECK-DAG:     %[[A2:.*]] = arith.constant 0 : index
 //       CHECK:     %[[A3:.*]] = memref.alloc() : memref<16xindex>
 //       CHECK:     %[[A4:.*]] = memref.cast %[[A3]] : memref<16xindex> to memref<?xindex>
 //       CHECK:     %[[A5:.*]] = memref.alloc() : memref<16xindex>
 //       CHECK:     %[[A6:.*]] = memref.cast %[[A5]] : memref<16xindex> to memref<?xindex>
 //       CHECK:     %[[A7:.*]] = memref.alloc() : memref<16xf64>
 //       CHECK:     %[[A8:.*]] = memref.cast %[[A7]] : memref<16xf64> to memref<?xf64>
 //       CHECK:     %[[A9:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier
 //       CHECK:     %[[A10:.*]] = arith.index_cast %[[A0]] : index to i64

 //       CHECK:     return %[[A23]], %[[A6]], %[[A8]], %[[A26]] : memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
 func.func @sparse_alloc_csc(%arg0: index) -> tensor<10x?xf64, #CSC> {
   %0 = bufferization.alloc_tensor(%arg0) : tensor<10x?xf64, #CSC>
   %1 = sparse_tensor.load %0 : tensor<10x?xf64, #CSC>
   return %1 : tensor<10x?xf64, #CSC>
 }
 
 // CHECK-LABEL:   func.func @sparse_alloc_3d() -> (memref<?xf64>, !sparse_tensor.storage_specifier
-//       CHECK:     %[[A0:.*]] = arith.constant 6000 : index
-//       CHECK:     %[[A1:.*]] = arith.constant 20 : i64
-//       CHECK:     %[[A2:.*]] = arith.constant 10 : i64
-//       CHECK:     %[[A3:.*]] = arith.constant 30 : i64
-//       CHECK:     %[[A4:.*]] = arith.constant 0.000000e+00 : f64
+//   CHECK-DAG:     %[[A0:.*]] = arith.constant 6000 : index
+//   CHECK-DAG:     %[[A1:.*]] = arith.constant 20 : i64
+//   CHECK-DAG:     %[[A2:.*]] = arith.constant 10 : i64
+//   CHECK-DAG:     %[[A3:.*]] = arith.constant 30 : i64
+//   CHECK-DAG:     %[[A4:.*]] = arith.constant 0.000000e+00 : f64
 //       CHECK:     %[[A5:.*]] = memref.alloc() : memref<6000xf64>
 //       CHECK:     %[[A6:.*]] = memref.cast %[[A5]] : memref<6000xf64> to memref<?xf64>
 //       CHECK:     %[[A7:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier
 //       CHECK:     %[[A8:.*]] = sparse_tensor.storage_specifier.set %[[A7]]  dim_sz at 0 with %[[A3]] : i64, !sparse_tensor.storage_specifier
 //       CHECK:     %[[A9:.*]] = sparse_tensor.storage_specifier.set %[[A8]]  dim_sz at 1 with %[[A2]] : i64, !sparse_tensor.storage_specifier
 //       CHECK:     %[[A10:.*]] = sparse_tensor.storage_specifier.set %[[A9]]  dim_sz at 2 with %[[A1]] : i64, !sparse_tensor.storage_specifier
 //       CHECK:     %[[A11:.*]] = sparse_tensor.storage_specifier.get %[[A10]]  val_mem_sz : !sparse_tensor.storage_specifier
 //       CHECK:     %[[A12:.*]] = arith.index_cast %[[A11]] : i64 to index

 //  CHECK-SAME:     %[[A1:.*1]]: memref<?xi64>,
 //  CHECK-SAME:     %[[A2:.*2]]: memref<?xf64>,
 //  CHECK-SAME:     %[[A3:.*3]]: !sparse_tensor.storage_specifier
 //  CHECK-SAME:     %[[A4:.*4]]: memref<?xf64>,
 //  CHECK-SAME:     %[[A5:.*5]]: memref<?xi1>,
 //  CHECK-SAME:     %[[A6:.*6]]: memref<?xindex>,
 //  CHECK-SAME:     %[[A7:.*7]]: index,
 //  CHECK-SAME:     %[[A8:.*8]]: index) -> (memref<?xi32>, memref<?xi64>, memref<?xf64>, !sparse_tensor.storage_specifier
-//       CHECK:     %[[A9:.*]] = arith.constant 0 : i32
-//       CHECK:     %[[A10:.*]] = arith.constant false
-//       CHECK:     %[[A11:.*]] = arith.constant 0.000000e+00 : f64
-//       CHECK:     %[[A12:.*]] = arith.constant 1 : index
-//       CHECK:     %[[A13:.*]] = arith.constant 0 : index
+//   CHECK-DAG:     %[[A9:.*]] = arith.constant 0 : i32
+//   CHECK-DAG:     %[[A10:.*]] = arith.constant false
+//   CHECK-DAG:     %[[A11:.*]] = arith.constant 0.000000e+00 : f64
+//   CHECK-DAG:     %[[A12:.*]] = arith.constant 1 : index
+//   CHECK-DAG:     %[[A13:.*]] = arith.constant 0 : index
 //       CHECK:     sparse_tensor.sort %[[A7]], %[[A6]] : memref<?xindex>
 //       CHECK:     %[[A14:.*]]:4 = scf.for %[[A15:.*]] = %[[A13]] to %[[A7]] step %[[A12]] iter_args(%[[A16:.*]] = %[[A0]], %[[A17:.*]] = %[[A1]], %[[A18:.*]] = %[[A2]], %[[A19:.*]] = %[[A3]]) -> (memref<?xi32>, memref<?xi64>, memref<?xf64>, !sparse_tensor.storage_specifier
 //       CHECK:       %[[A20:.*]] = memref.load %[[A6]]{{\[}}%[[A15]]] : memref<?xindex>
 //       CHECK:       %[[A21:.*]] = memref.load %[[A4]]{{\[}}%[[A20]]] : memref<?xf64>
 //       CHECK:       %[[A22:.*]]:4 = func.call @_insert_dense_compressed_8_8_f64_64_32(%[[A16]], %[[A17]], %[[A18]], %[[A19]], %[[A8]], %[[A20]], %[[A21]]) : (memref<?xi32>, memref<?xi64>, memref<?xf64>, !sparse_tensor.storage_specifier
 //       CHECK:       memref.store %[[A11]], %[[A4]]{{\[}}%[[A20]]] : memref<?xf64>
 //       CHECK:       memref.store %[[A10]], %[[A5]]{{\[}}%[[A20]]] : memref<?xi1>
 //       CHECK:       scf.yield %[[A22]]#0, %[[A22]]#1, %[[A22]]#2, %[[A22]]#3 : memref<?xi32>, memref<?xi64>, memref<?xf64>, !sparse_tensor.storage_specifier

 //  CHECK-SAME:     %[[A1:.*1]]: memref<?xindex>,
 //  CHECK-SAME:     %[[A2:.*2]]: memref<?xf64>,
 //  CHECK-SAME:     %[[A3:.*3]]: !sparse_tensor.storage_specifier
 //  CHECK-SAME:     %[[A4:.*4]]: memref<?xf64>,
 //  CHECK-SAME:     %[[A5:.*5]]: memref<?xi1>,
 //  CHECK-SAME:     %[[A6:.*6]]: memref<?xindex>,
 //  CHECK-SAME:     %[[A7:.*7]]: index,
 //  CHECK-SAME:     %[[A8:.*8]]: index) -> (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
-//       CHECK:     %[[A9:.*]] = arith.constant false
-//       CHECK:     %[[A10:.*]] = arith.constant 0.000000e+00 : f64
-//       CHECK:     %[[A11:.*]] = arith.constant 0 : index
-//       CHECK:     %[[A12:.*]] = arith.constant 1 : index
+//   CHECK-DAG:     %[[A9:.*]] = arith.constant false
+//   CHECK-DAG:     %[[A10:.*]] = arith.constant 0.000000e+00 : f64
+//   CHECK-DAG:     %[[A11:.*]] = arith.constant 0 : index
+//   CHECK-DAG:     %[[A12:.*]] = arith.constant 1 : index
 //       CHECK:     %[[A13:.*]]:4 = scf.for %[[A14:.*]] = %[[A11]] to %[[A7]] step %[[A12]] iter_args(%[[A15:.*]] = %[[A0]], %[[A16:.*]] = %[[A1]], %[[A17:.*]] = %[[A2]], %[[A18:.*]] = %[[A3]]) -> (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
 //       CHECK:       %[[A19:.*]] = memref.load %[[A6]]{{\[}}%[[A14]]] : memref<?xindex>
 //       CHECK:       %[[A20:.*]] = memref.load %[[A4]]{{\[}}%[[A19]]] : memref<?xf64>
 //       CHECK:       %[[A21:.*]]:4 = func.call @"_insert_dense_compressed-no_8_8_f64_0_0"(%[[A15]], %[[A16]], %[[A17]], %[[A18]], %[[A8]], %[[A19]], %[[A20]]) : (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
 //       CHECK:       memref.store %[[A10]], %[[A4]]{{\[}}%[[A19]]] : memref<?xf64>
 //       CHECK:       memref.store %[[A9]], %[[A5]]{{\[}}%[[A19]]] : memref<?xi1>
 //       CHECK:       scf.yield %[[A21]]#0, %[[A21]]#1, %[[A21]]#2, %[[A21]]#3 : memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
 //       CHECK:     }

mlir/test/Dialect/SparseTensor/codegen_buffer_initialization.mlir

 // RUN: mlir-opt %s --sparse-tensor-codegen=enable-buffer-initialization=true  --canonicalize --cse | FileCheck %s
 
 #SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>
 
 // CHECK-LABEL:   func.func @sparse_alloc_sparse_vector(
 //  CHECK-SAME:     %[[VAL_0:.*]]: index) -> (memref<?xindex>, memref<?xindex>, memref<?xf64>, !sparse_tensor.storage_specifier
-//       CHECK:     %[[VAL_1:.*]] = arith.constant 1 : index
-//       CHECK:     %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64
-//       CHECK:     %[[VAL_3:.*]] = arith.constant 0 : index
+//   CHECK-DAG:     %[[VAL_1:.*]] = arith.constant 1 : index
+//   CHECK-DAG:     %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64
+//   CHECK-DAG:     %[[VAL_3:.*]] = arith.constant 0 : index
 //       CHECK:     %[[VAL_4:.*]] = memref.alloc() : memref<16xindex>
 //       CHECK:     %[[VAL_5:.*]] = memref.cast %[[VAL_4]] : memref<16xindex> to memref<?xindex>
 //       CHECK:     linalg.fill ins(%[[VAL_3]] : index) outs(%[[VAL_4]] : memref<16xindex>)
 //       CHECK:     %[[VAL_6:.*]] = memref.alloc() : memref<16xindex>
 //       CHECK:     %[[VAL_7:.*]] = memref.cast %[[VAL_6]] : memref<16xindex> to memref<?xindex>
 //       CHECK:     linalg.fill ins(%[[VAL_3]] : index) outs(%[[VAL_6]] : memref<16xindex>)
 //       CHECK:     %[[VAL_8:.*]] = memref.alloc() : memref<16xf64>
 //       CHECK:     %[[VAL_9:.*]] = memref.cast %[[VAL_8]] : memref<16xf64> to memref<?xf64>

mlir/test/Dialect/SparseTensor/sparse_fp_ops.mlir

func.func @zero_preserving_math(%arga: tensor<32xf64, #SV>) -> tensor<32xf64, #SV> {
   } -> tensor<32xf64, #SV>
   return %0 : tensor<32xf64, #SV>
 }
 
 // CHECK-LABEL:   func.func @complex_divbyc(
 // CHECK-SAME:      %[[VAL_0:.*]]: tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>) -> tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> {
 // CHECK-DAG:       %[[VAL_1:.*]] = arith.constant 0 : index
 // CHECK-DAG:       %[[VAL_2:.*]] = arith.constant 1 : index
-// CHECK:           %[[VAL_3:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
+// CHECK-DAG:       %[[VAL_3:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
 // CHECK:           %[[VAL_4:.*]] = bufferization.alloc_tensor() : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>>
 // CHECK:           %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]] {dimension = 0 : index} : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]] {dimension = 0 : index} : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xcomplex<f64>, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>> to memref<?xcomplex<f64>>
 // CHECK:           %[[VAL_8:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_1]]] : memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex>
 // CHECK:           %[[T:.*]] = scf.for %[[VAL_10:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_2]] {{.*}} {
 // CHECK:             %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xindex>

mlir/test/Dialect/SparseTensor/sparse_matmul_codegen.mlir

 // CHECK-SAME:      %[[VAL_0:.*0]]: memref<?xindex>,
 // CHECK-SAME:      %[[VAL_1:.*1]]: memref<?xindex>,
 // CHECK-SAME:      %[[VAL_2:.*2]]: memref<?xf64>,
 // CHECK-SAME:      %[[VAL_3:.*3]]: !sparse_tensor.storage_specifier
 // CHECK-SAME:      %[[VAL_4:.*4]]: memref<?xindex>,
 // CHECK-SAME:      %[[VAL_5:.*5]]: memref<?xindex>,
 // CHECK-SAME:      %[[VAL_6:.*6]]: memref<?xf64>,
 // CHECK-SAME:      %[[VAL_7:.*7]]: !sparse_tensor.storage_specifier
-// CHECK:           %[[VAL_8:.*]] = arith.constant 4 : index
-// CHECK:           %[[VAL_9:.*]] = arith.constant 4 : i64
-// CHECK:           %[[VAL_10:.*]] = arith.constant 0.000000e+00 : f64
-// CHECK:           %[[VAL_11:.*]] = arith.constant 0 : index
-// CHECK:           %[[VAL_12:.*]] = arith.constant 1 : index
-// CHECK:           %[[VAL_13:.*]] = arith.constant false
-// CHECK:           %[[VAL_14:.*]] = arith.constant true
+// CHECK-DAG:       %[[VAL_8:.*]] = arith.constant 4 : index
+// CHECK-DAG:       %[[VAL_9:.*]] = arith.constant 4 : i64
+// CHECK-DAG:       %[[VAL_10:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK-DAG:       %[[VAL_11:.*]] = arith.constant 0 : index
+// CHECK-DAG:       %[[VAL_12:.*]] = arith.constant 1 : index
+// CHECK-DAG:       %[[VAL_13:.*]] = arith.constant false
+// CHECK-DAG:       %[[VAL_14:.*]] = arith.constant true
 // CHECK:           %[[VAL_15:.*]] = memref.alloc() : memref<16xindex>
 // CHECK:           %[[VAL_16:.*]] = memref.cast %[[VAL_15]] : memref<16xindex> to memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = memref.alloc() : memref<16xindex>
 // CHECK:           %[[VAL_18:.*]] = memref.cast %[[VAL_17]] : memref<16xindex> to memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = memref.alloc() : memref<16xf64>
 // CHECK:           %[[VAL_20:.*]] = memref.cast %[[VAL_19]] : memref<16xf64> to memref<?xf64>
 // CHECK:           %[[VAL_21:.*]] = sparse_tensor.storage_specifier.init : !sparse_tensor.storage_specifier
 // CHECK:           %[[VAL_22:.*]] = sparse_tensor.storage_specifier.set %[[VAL_21]]  dim_sz at 0 with %[[VAL_9]] : i64, !sparse_tensor.storage_specifier

mlir/test/Dialect/Vector/vector-transfer-flatten.mlir

func.func @transfer_read_flattenable_with_dynamic_dims_and_indices(%arg0 : memref<?x?x8x4xi8, strided<[?, 32, 4, 1], offset: ?>>, %arg1 : index, %arg2 : index) -> vector<8x4xi8> {
     %c0_i8 = arith.constant 0 : i8
     %c0 = arith.constant 0 : index
     %result = vector.transfer_read %arg0[%arg1, %arg2, %c0, %c0], %c0_i8 {in_bounds = [true, true]} : memref<?x?x8x4xi8, strided<[?, 32, 4, 1], offset: ?>>, vector<8x4xi8>
     return %result : vector<8x4xi8>
 }
 
 // CHECK-LABEL: func @transfer_read_flattenable_with_dynamic_dims_and_indices
 // CHECK-SAME:    %[[ARG0:.+]]: memref<?x?x8x4xi8, {{.+}}>, %[[ARG1:.+]]: index, %[[ARG2:.+]]: index
-// CHECK:       %[[C0_I8:.+]] = arith.constant 0 : i8
-// CHECK:       %[[C0:.+]] = arith.constant 0 : index
+// CHECK-DAG:   %[[C0_I8:.+]] = arith.constant 0 : i8
+// CHECK-DAG:   %[[C0:.+]] = arith.constant 0 : index
 // CHECK:       %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG0]] {{\[}}[0], [1], [2, 3]{{\]}}
 // CHECK-SAME:    : memref<?x?x8x4xi8, {{.+}}> into memref<?x?x32xi8, {{.+}}>
 // CHECK:       %[[VEC1D:.+]] = vector.transfer_read %[[COLLAPSED]]
 // CHECK-SAME:    [%[[ARG1]], %[[ARG2]], %[[C0]]], %[[C0_I8]]
 // CHECK-SAME:    {in_bounds = [true]}
 // CHECK-SAME:    : memref<?x?x32xi8, {{.+}}>, vector<32xi8>
 // CHECK:       %[[VEC2D:.+]] = vector.shape_cast %[[VEC1D]] : vector<32xi8> to vector<8x4xi8>
 // CHECK:       return %[[VEC2D]] : vector<8x4xi8>

mlir/test/Transforms/test-operation-folder.mlir

func.func @test_fold_before_previously_folded_op() -> (i32, i32) {
   // CHECK: %[[CST:.+]] = arith.constant true
   // CHECK-NEXT: "test.cast"(%[[CST]]) : (i1) -> i32
   // CHECK-NEXT: "test.cast"(%[[CST]]) : (i1) -> i32
 
   %0 = "test.cast"() {test_fold_before_previously_folded_op} : () -> (i32)
   %1 = "test.cast"() {test_fold_before_previously_folded_op} : () -> (i32)
   return %0, %1 : i32, i32
 }
-
-func.func @test_dont_reorder_constants() -> (i32, i32, i32) {
-  // Test that we don't reorder existing constants during folding if it isn't necessary.
-  // CHECK: %[[CST:.+]] = arith.constant 1
-  // CHECK-NEXT: %[[CST:.+]] = arith.constant 2
-  // CHECK-NEXT: %[[CST:.+]] = arith.constant 3
-  %0 = arith.constant 1 : i32
-  %1 = arith.constant 2 : i32
-  %2 = arith.constant 3 : i32
-  return %0, %1, %2 : i32, i32, i32
-}