[Mlir-commits] [mlir] [mlir][sparse] refactoring: using util functions to query the index to load from position array for slice-driven loop. (PR #73986)
Peiming Liu
llvmlistbot at llvm.org
Thu Nov 30 13:03:01 PST 2023
https://github.com/PeimingLiu created https://github.com/llvm/llvm-project/pull/73986
None
>From b7e5a9023f35ade59124c4510b79b619e1b07d53 Mon Sep 17 00:00:00 2001
From: Peiming Liu <peiming at google.com>
Date: Thu, 30 Nov 2023 20:41:42 +0000
Subject: [PATCH] cleanup
---
.../SparseTensor/Transforms/LoopEmitter.cpp | 167 ++++---
.../SparsificationAndBufferizationPass.cpp | 2 +-
.../sparse_conv_2d_slice_based.mlir | 413 +++++++++---------
3 files changed, 308 insertions(+), 274 deletions(-)
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp
index a245344755f0404..50ac86f1c6165bb 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp
@@ -148,23 +148,60 @@ static Value genSparseReducedAffineCond(OpBuilder &builder, Location loc,
// Helper functions that load/store into the position buffer for slice-driven
// loops.
// The sliced pointer buffer is orgnized as:
-// [size, curPtr] (two metadata) + [[pLo, pHi, pNext], ...] (list of tuples)
+// [size, curPtr] (two metadata) + [[pLo0, pLo1, pLo2, ...],
+// [pHi0, pHi1, pHi2, ...],
+// [pNx0, pNx1, pNx2, ...]]
+static Value allocSlicePosBuf(OpBuilder &builder, Location loc,
+ Value tupleCnt) {
+ Value bufSz = MULI(tupleCnt, C_IDX(kSliceIterWidth));
+ // Additional two metadata {memSize, idx} at head.
+ bufSz = ADDI(bufSz, C_IDX(2));
+ return genAlloca(builder, loc, bufSz, builder.getIndexType());
+}
+// TODO: We should use SSA value for it.
+// Gets and sets metadata.
static Value loadSlicePosPtr(OpBuilder &builder, Location loc, Value sPosBuf) {
- // Load curPtr.
- // TODO: We should use SSA value for it.
return genIndexLoad(builder, loc, sPosBuf, C_IDX(1));
}
static void updateSlicePosPtr(OpBuilder &builder, Location loc, Value sPosBuf,
Value pPtr) {
- // Set curPtr.
- // TODO: We should use SSA value for it.
builder.create<memref::StoreOp>(loc, pPtr, sPosBuf, C_IDX(1));
}
-static Value loadSliceNextPosPtrStart(OpBuilder &builder, Location loc,
- Value sPosBuf, Value tupleIdx) {
- // load the pNext in the current tuple specified by `tupleIdx`.
- // 4 = 2 (two metadata) + 2 (pNext == tuple[2])
- return genIndexLoad(builder, loc, sPosBuf, ADDI(tupleIdx, C_IDX(4)));
+static Value loadSlicePosTupleNum(OpBuilder &builder, Location loc,
+ Value sPosBuf) {
+ return genIndexLoad(builder, loc, sPosBuf, C_IDX(0));
+}
+static void updateSlicePosTupleNum(OpBuilder &builder, Location loc, Value num,
+ Value sPosBuf) {
+ builder.create<memref::StoreOp>(loc, num, sPosBuf, C_IDX(0));
+}
+
+// Gets and sets position values for slice-driven loops.
+enum class SlicePosKind { kLo, kHi, kNext };
+static Value getSlicePosIdx(OpBuilder &builder, Location loc, Value posBuf,
+ Value tupleIdx, SlicePosKind posKind) {
+ Value dim = builder.create<memref::DimOp>(loc, posBuf, C_IDX(0));
+ Value tupleCnt = DIVUI(SUBI(dim, C_IDX(2)), C_IDX(kSliceIterWidth));
+ switch (posKind) {
+ case SlicePosKind::kLo:
+ return ADDI(tupleIdx, C_IDX(2));
+ case SlicePosKind::kHi:
+ return ADDI(tupleIdx, ADDI(tupleCnt, C_IDX(2)));
+ case SlicePosKind::kNext:
+ return ADDI(tupleIdx, ADDI(tupleCnt, ADDI(tupleCnt, C_IDX(2))));
+ }
+ llvm_unreachable("unexpected kind");
+}
+static Value loadSlicePos(OpBuilder &builder, Location loc, Value sPosBuf,
+ Value tupleIdx, SlicePosKind posKind) {
+ return genIndexLoad(builder, loc, sPosBuf,
+ getSlicePosIdx(builder, loc, sPosBuf, tupleIdx, posKind));
+}
+static void updateSlicePos(OpBuilder &builder, Location loc, Value sPosBuf,
+ Value pos, Value tupleIdx, SlicePosKind posKind) {
+ builder.create<memref::StoreOp>(
+ loc, pos, sPosBuf,
+ getSlicePosIdx(builder, loc, sPosBuf, tupleIdx, posKind));
}
std::pair<Value, Value>
@@ -1446,13 +1483,13 @@ void LoopEmitter::forwardsReducedSliceLevelTreeIt(OpBuilder &builder,
// The first compressed level, setting up the position pointer for it.
Value sPosBuf = slicePosBuffer[tid][curLvl].back();
// One step forwards in the parent level result in forwarding one `segment`
- // (kSliceIterWidth) in the child sparse level.
- Value fPosPtr = MULI(fcnt, C_IDX(kSliceIterWidth)); // forward ptr
+ // in the child sparse level.
Value pPosPtr = loadSlicePosPtr(builder, loc, sPosBuf); // previous ptr
- Value cPosPtr = ADDI(fPosPtr, pPosPtr); // current ptr
+ Value cPosPtr = ADDI(fcnt, pPosPtr); // current ptr
updateSlicePosPtr(builder, loc, sPosBuf, cPosPtr);
// Loads the position pointer start for next level.
- nxPosPtr = loadSliceNextPosPtrStart(builder, loc, sPosBuf, cPosPtr);
+ nxPosPtr =
+ loadSlicePos(builder, loc, sPosBuf, cPosPtr, SlicePosKind::kNext);
curLvl++;
}
@@ -1464,10 +1501,10 @@ void LoopEmitter::forwardsReducedSliceLevelTreeIt(OpBuilder &builder,
for (; curLvl < leafLvl; curLvl++) {
assert(nxPosPtr);
if (!isDenseLT(lvlTypes[tid][curLvl])) {
- nxPosPtr = MULI(nxPosPtr, C_IDX(kSliceIterWidth));
Value sPosBuf = slicePosBuffer[tid][curLvl].back();
updateSlicePosPtr(builder, loc, sPosBuf, nxPosPtr);
- nxPosPtr = loadSliceNextPosPtrStart(builder, loc, sPosBuf, nxPosPtr);
+ nxPosPtr =
+ loadSlicePos(builder, loc, sPosBuf, nxPosPtr, SlicePosKind::kNext);
}
}
}
@@ -1737,7 +1774,7 @@ ValueRange LoopEmitter::genUnResolvedSliceTreeTraverse(
std::optional<std::pair<TensorId, Level>> firstResLvl, ValueRange userReduc,
LoopBodyBuilder bodyBuilder) {
- Value c0 = C_IDX(0), c1 = C_IDX(1), c2 = C_IDX(2);
+ Value c0 = C_IDX(0), c1 = C_IDX(1);
Value pos = c0;
OpBuilder::InsertPoint ip;
SmallVector<Value> innerArgs(userReduc.begin(), userReduc.end());
@@ -1770,20 +1807,22 @@ ValueRange LoopEmitter::genUnResolvedSliceTreeTraverse(
unsigned depth = frontSlice.depth - 1;
Value offset = frontSlice.offset;
Value sPtrBuf = slicePosBuffer[tid][firstLvl][depth];
- Value mSz = genIndexLoad(builder, loc, sPtrBuf, c0); // memSize
+ Value mSz = loadSlicePosTupleNum(builder, loc, sPtrBuf);
outerMost = builder.create<scf::ForOp>(
- loc, c2, mSz, C_IDX(kSliceIterWidth), innerArgs,
- [this, c1, c2, tid, firstLvl, offset, sPtrBuf, &ip, &pos,
+ loc, c0, mSz, c1, innerArgs,
+ [this, tid, firstLvl, offset, sPtrBuf, &ip, &pos,
&innerArgs](OpBuilder &builder, Location loc, Value iv,
ValueRange iterArgs) {
// generate traversal for each level.
- Value loopLo = genIndexLoad(builder, loc, sPtrBuf, iv);
- Value loopHi = genIndexLoad(builder, loc, sPtrBuf, ADDI(iv, c1));
+ Value loopLo =
+ loadSlicePos(builder, loc, sPtrBuf, iv, SlicePosKind::kLo);
+ Value loopHi =
+ loadSlicePos(builder, loc, sPtrBuf, iv, SlicePosKind::kHi);
// We need to remember the starting index for next level's
// position, because slice-driven loop breaks the level into
// non-consecutive segments.
- builder.create<memref::StoreOp>(loc, iterArgs.back(), sPtrBuf,
- ADDI(iv, c2).getResult());
+ updateSlicePos(builder, loc, sPtrBuf, iterArgs.back(), iv,
+ SlicePosKind::kNext);
auto [size, stride] = sliceMeta[tid][firstLvl].back();
assert(stride == 1 && "Not yet implemented");
@@ -1874,8 +1913,7 @@ ValueRange LoopEmitter::genUnResolvedSliceTreeTraverse(
void LoopEmitter::genResolvedSliceBegin(OpBuilder &builder, Location loc,
TensorId tid, Level lvl) {
- Value c0 = C_IDX(0), c1 = C_IDX(1), c2 = C_IDX(2), c3 = C_IDX(3),
- c4 = C_IDX(4);
+ Value c0 = C_IDX(0), c1 = C_IDX(1);
if (isDenseLT(lvlTypes[tid][lvl])) {
// Dense slice begin is trivial.
sliceStack[tid].emplace_back(/*minCoord=*/c0, /*offset=*/c0,
@@ -1897,10 +1935,10 @@ void LoopEmitter::genResolvedSliceBegin(OpBuilder &builder, Location loc,
ADDI(posits[tid][lvl - 1], c1));
}
// Fills out pIdxBuffer[tid][lvl][0] with [/*memSize =*/4, 0, pLo, pHi]
- builder.create<memref::StoreOp>(loc, c4, sPtrBuf, c0); // memSize = 4
- builder.create<memref::StoreOp>(loc, c0, sPtrBuf, c1); // index = 0
- builder.create<memref::StoreOp>(loc, pLo, sPtrBuf, c2); // pLo
- builder.create<memref::StoreOp>(loc, pHi, sPtrBuf, c3); // pHi
+ updateSlicePosTupleNum(builder, loc, c1, sPtrBuf);
+ updateSlicePosPtr(builder, loc, sPtrBuf, c0);
+ updateSlicePos(builder, loc, sPtrBuf, pLo, c0, SlicePosKind::kLo);
+ updateSlicePos(builder, loc, sPtrBuf, pHi, c0, SlicePosKind::kHi);
// This is an non empty tensor if pLo < pHi.
Value isNonEmpty = CMPI(ult, pLo, pHi);
@@ -1939,7 +1977,7 @@ void LoopEmitter::genResolvedSliceBegin(OpBuilder &builder, Location loc,
// }
void LoopEmitter::genUnResolvedSliceBegin(OpBuilder &builder, Location loc,
TensorId tid, Level lvl) {
- Value c0 = C_IDX(0), c1 = C_IDX(1), c2 = C_IDX(2);
+ Value c0 = C_IDX(0), c1 = C_IDX(1);
unsigned depth = levelReducedDep[tid][lvl];
// The remaining slice size after reduction.
Value remSz = sliceMeta[tid][lvl][depth + 1].first;
@@ -1984,7 +2022,7 @@ void LoopEmitter::genUnResolvedSliceBegin(OpBuilder &builder, Location loc,
SmallVector<Value, 3> reduc = {
constantI1(builder, loc, false), // isNonEmpty
lvlSizes[tid][lvl], // minCoord
- c2, // memSize
+ c0, // memSize
};
ValueRange result = genUnResolvedSliceTreeTraverse(
@@ -1993,7 +2031,7 @@ void LoopEmitter::genUnResolvedSliceBegin(OpBuilder &builder, Location loc,
MutableArrayRef<Value> reduc) {
Value &nonEmpty = reduc[0];
Value &minCrd = reduc[1];
- Value &curMemSz = reduc[2];
+ Value &curTupleCnt = reduc[2];
Value pHi = ADDI(iv, c1);
Value sPLo = genIndexLoad(builder, loc, positionsBuffers[tid][lvl], iv);
@@ -2025,19 +2063,19 @@ void LoopEmitter::genUnResolvedSliceBegin(OpBuilder &builder, Location loc,
YIELD(minCrd);
}
minCrd = ifNonEmpty.getResult(0);
- builder.create<memref::StoreOp>(loc, sPLo, sPtrBuf, curMemSz);
- Value nxtMemSize = ADDI(curMemSz, c1);
- builder.create<memref::StoreOp>(loc, sPHi, sPtrBuf, nxtMemSize);
- // curMemSize += kSliceIterWidth
- curMemSz = ADDI(curMemSz, C_IDX(kSliceIterWidth));
+ updateSlicePos(builder, loc, sPtrBuf, sPLo, curTupleCnt,
+ SlicePosKind::kLo);
+ updateSlicePos(builder, loc, sPtrBuf, sPHi, curTupleCnt,
+ SlicePosKind::kHi);
+ curTupleCnt = ADDI(curTupleCnt, C_IDX(1));
});
Value isNonEmpty = result[0];
Value minCrd = result[1];
// Two metadata [memSize, idx].
// TODO: Can use an SSA value for these two metadata
- builder.create<memref::StoreOp>(loc, result[2], sPtrBuf, c0);
- builder.create<memref::StoreOp>(loc, c0, sPtrBuf, c1);
+ updateSlicePosTupleNum(builder, loc, result[2], sPtrBuf);
+ updateSlicePosPtr(builder, loc, sPtrBuf, c0);
// FIXME: we need the relative offset related to the base slice.
Value absOffset = offsetFromMinCoord(builder, loc, minCrd, remSz, isNonEmpty);
sliceStack[tid].emplace_back(minCrd, absOffset, isNonEmpty, lvl, depth + 1);
@@ -2045,8 +2083,6 @@ void LoopEmitter::genUnResolvedSliceBegin(OpBuilder &builder, Location loc,
bool LoopEmitter::genSliceBegin(OpBuilder &builder, Location loc, TensorId tid,
Level lvl) {
- Value c1 = C_IDX(1), c2 = C_IDX(2);
-
if (depFullyReduced(tid, lvl)) {
// Do not need to prepare for slice driven loop on dense level after it is
// fully reduced.
@@ -2055,14 +2091,12 @@ bool LoopEmitter::genSliceBegin(OpBuilder &builder, Location loc, TensorId tid,
// If constraints on the tensor is fully resolved. We do not need to
// generates slice begin any more, instead we fall back to TACO-based
// algorithm to (co)iterates over the slice.
- Value pLoPtr =
- loadSlicePosPtr(builder, loc, slicePosBuffer[tid][lvl].back());
- pLoPtr = ADDI(pLoPtr, c2);
- Value pHiPtr = ADDI(pLoPtr, c1);
+ Value sPosBuf = slicePosBuffer[tid][lvl].back();
+ Value tupleIdx = loadSlicePosPtr(builder, loc, sPosBuf);
posits[tid][lvl] =
- genIndexLoad(builder, loc, slicePosBuffer[tid][lvl].back(), pLoPtr);
+ loadSlicePos(builder, loc, sPosBuf, tupleIdx, SlicePosKind::kLo);
highs[tid][lvl] =
- genIndexLoad(builder, loc, slicePosBuffer[tid][lvl].back(), pHiPtr);
+ loadSlicePos(builder, loc, sPosBuf, tupleIdx, SlicePosKind::kHi);
return true;
}
@@ -2091,8 +2125,7 @@ bool LoopEmitter::genSliceBegin(OpBuilder &builder, Location loc, TensorId tid,
// The buffer can be reused, and the size is loop invariant: it only
// depends on the iteration graph's toposort.
builder.setInsertionPointAfter(localInsertPos);
- Value bufSize = C_IDX(1);
- Value c2 = C_IDX(2);
+ Value tupleCnt = C_IDX(1);
// Accumlates the size required to cache the pLo for the slice.
// E.g., if we want to cache the pIdx for slice<d0xd1xf64> on the second
// level. We at most need to a memref<d0xindex>.
@@ -2109,16 +2142,10 @@ bool LoopEmitter::genSliceBegin(OpBuilder &builder, Location loc, TensorId tid,
assert(!sliceMeta[tid][curLevel - 1].empty());
auto [sz, stride] = sliceMeta[tid][curLevel - 1].back();
assert(stride == 1 && "Not yet implemented");
- bufSize = MULI(bufSize, sz);
+ tupleCnt = MULI(tupleCnt, sz);
}
- // For a triple of [pLo, pHi, pPtr]. Note that we can not compress pHi
- // because slice creates segments in the index buffer so that the pHi for
- // the current level is no longer the pLo for the next level.
- bufSize = MULI(bufSize, C_IDX(kSliceIterWidth));
- // Additional two metadata {memSize, idx} at head.
- bufSize = ADDI(bufSize, c2);
for (Value &cache : slicePosBuffer[tid][lvl])
- cache = genAlloca(builder, loc, bufSize, builder.getIndexType());
+ cache = allocSlicePosBuf(builder, loc, tupleCnt);
}
if (sliceInfo.isInitialTensor() ||
@@ -2148,7 +2175,7 @@ LoopEmitter::genSliceNextInduction(OpBuilder &builder, Location loc,
llvm_unreachable("TODO");
// else generate code to compute next non empty slice.
- Value c0 = C_IDX(0), c1 = C_IDX(1), c2 = C_IDX(2);
+ Value c0 = C_IDX(0), c1 = C_IDX(1);
SliceInfo &info = sliceStack[tid].back();
assert(info.slicedOnLvl == lvl);
@@ -2195,14 +2222,13 @@ LoopEmitter::genSliceNextInduction(OpBuilder &builder, Location loc,
// offset = minCrd - size + 1;
// }
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
- reduc[2] = absOffset; // restore value.
- Value pSt = c2; // pointer starting index
- Value mSz = genIndexLoad(builder, loc, sPtrBuf, c0); // memSize
- reduc[0] = lvlSizes[tid][lvl]; // next min coord
- reduc[1] = constantI1(builder, loc, false); // isNonEmpty
+ reduc[2] = absOffset; // restore value.
+ Value mSz = loadSlicePosTupleNum(builder, loc, sPtrBuf); // memSize
+ reduc[0] = lvlSizes[tid][lvl]; // next min coord
+ reduc[1] = constantI1(builder, loc, false); // isNonEmpty
auto loopArgs = static_cast<ValueRange>(reduc).drop_back();
auto forOp = scf::buildLoopNest(
- builder, loc, pSt, mSz, C_IDX(kSliceIterWidth), loopArgs,
+ builder, loc, c0, mSz, c1, loopArgs,
[this, tid, lvl, c1, sPtrBuf,
&info](OpBuilder &builder, Location loc, ValueRange ivs,
ValueRange iterArgs) -> scf::ValueVector {
@@ -2210,9 +2236,10 @@ LoopEmitter::genSliceNextInduction(OpBuilder &builder, Location loc,
Value isNonEmpty = iterArgs[1];
Type idxTp = builder.getIndexType();
- Value pLo = genIndexLoad(builder, loc, sPtrBuf, ivs.front());
- Value pHi =
- genIndexLoad(builder, loc, sPtrBuf, ADDI(ivs.front(), c1));
+ Value pLo = loadSlicePos(builder, loc, sPtrBuf, ivs.front(),
+ SlicePosKind::kLo);
+ Value pHi = loadSlicePos(builder, loc, sPtrBuf, ivs.front(),
+ SlicePosKind::kHi);
//
// if (pLo < pHi) // Only loads when inbound.
// coord = load[pLo]
@@ -2236,8 +2263,8 @@ LoopEmitter::genSliceNextInduction(OpBuilder &builder, Location loc,
&ifEqual.getThenRegion().front());
Value newPlo = ADDI(pLo, c1);
// Updates the cache.
- builder.create<memref::StoreOp>(loc, newPlo, sPtrBuf,
- ivs.front());
+ updateSlicePos(builder, loc, sPtrBuf, newPlo, ivs.front(),
+ SlicePosKind::kLo);
YIELD(newPlo);
}
/* else coord != minCrd */ {
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/SparsificationAndBufferizationPass.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/SparsificationAndBufferizationPass.cpp
index 94b25a358e804a7..6266c63064ffbd8 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/SparsificationAndBufferizationPass.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/SparsificationAndBufferizationPass.cpp
@@ -150,8 +150,8 @@ class SparsificationAndBufferizationPass
pm.addPass(
createSparseReinterpretMapPass(ReinterpretMapScope::kExceptGeneric));
pm.addNestedPass<func::FuncOp>(createLowerForeachToSCFPass());
+ pm.addPass(mlir::createLoopInvariantCodeMotionPass());
if (vectorLength > 0) {
- pm.addPass(mlir::createLoopInvariantCodeMotionPass());
pm.addPass(createSparseVectorizationPass(
vectorLength, enableVLAVectorization, enableSIMDIndex32));
}
diff --git a/mlir/test/Dialect/SparseTensor/sparse_conv_2d_slice_based.mlir b/mlir/test/Dialect/SparseTensor/sparse_conv_2d_slice_based.mlir
index 0cd57ac64b50012..0f99a0206e4cb85 100644
--- a/mlir/test/Dialect/SparseTensor/sparse_conv_2d_slice_based.mlir
+++ b/mlir/test/Dialect/SparseTensor/sparse_conv_2d_slice_based.mlir
@@ -6,258 +6,265 @@
#DCSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : compressed, d1 : compressed) }>
+
// CHECK-LABEL: func.func @conv2d_all_sparse_CSR(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<8x8xi32, #sparse{{[0-9]*}}>,
-// CHECK-SAME: %[[VAL_1:.*]]: tensor<3x3xi32>) -> tensor<6x6xi32, #sparse{{[0-9]*}}> {
+// CHECK-SAME: %[[VAL_1:.*]]: tensor<3x3xi32>) -> tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK-DAG: %[[VAL_2:.*]] = arith.constant true
// CHECK-DAG: %[[VAL_3:.*]] = arith.constant -2 : index
-// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : index
-// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 3 : index
-// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index
+// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 4 : index
+// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 8 : index
+// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 3 : index
// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index
-// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 2 : index
-// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 4 : index
-// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 0 : i32
-// CHECK-DAG: %[[VAL_11:.*]] = arith.constant false
-// CHECK-DAG: %[[VAL_12:.*]] = tensor.empty() : tensor<6x6xi32, #sparse{{[0-9]*}}>
-// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
-// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
-// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
-// CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
-// CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xi32>
-// CHECK-DAG: %[[VAL_18:.*]] = memref.alloca() : memref<11xindex>
-// CHECK-DAG: %[[VAL_19:.*]] = memref.alloca() : memref<5xindex>
-// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<?xindex>
-// CHECK: memref.store %[[VAL_9]], %[[VAL_19]]{{\[}}%[[VAL_6]]] : memref<5xindex>
-// CHECK: memref.store %[[VAL_6]], %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<5xindex>
-// CHECK: memref.store %[[VAL_6]], %[[VAL_19]]{{\[}}%[[VAL_8]]] : memref<5xindex>
-// CHECK: memref.store %[[VAL_20]], %[[VAL_19]]{{\[}}%[[VAL_5]]] : memref<5xindex>
-// CHECK: %[[VAL_21:.*]] = arith.cmpi ugt, %[[VAL_20]], %[[VAL_6]] : index
-// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<?xindex>
-// CHECK: %[[VAL_23:.*]] = arith.cmpi uge, %[[VAL_22]], %[[VAL_5]] : index
-// CHECK: %[[VAL_24:.*]] = arith.andi %[[VAL_21]], %[[VAL_23]] : i1
-// CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_22]], %[[VAL_3]] : index
-// CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_24]], %[[VAL_25]], %[[VAL_6]] : index
-// CHECK: %[[VAL_27:.*]]:3 = scf.while (%[[VAL_28:.*]] = %[[VAL_21]], %[[VAL_29:.*]] = %[[VAL_22]], %[[VAL_30:.*]] = %[[VAL_26]], %[[VAL_31:.*]] = %[[VAL_12]]) : (i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) -> (index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) {
-// CHECK: scf.condition(%[[VAL_28]]) %[[VAL_29]], %[[VAL_30]], %[[VAL_31]] : index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 5 : index
+// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 2 : index
+// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 0 : index
+// CHECK-DAG: %[[VAL_11:.*]] = arith.constant 0 : i32
+// CHECK-DAG: %[[VAL_12:.*]] = arith.constant false
+// CHECK-DAG: %[[VAL_13:.*]] = tensor.empty() : tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
+// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
+// CHECK-DAG: %[[VAL_16:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
+// CHECK-DAG: %[[VAL_17:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xindex>
+// CHECK-DAG: %[[VAL_18:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<8x8xi32, #sparse{{[0-9]*}}> to memref<?xi32>
+// CHECK-DAG: %[[VAL_19:.*]] = memref.alloca() : memref<11xindex>
+// CHECK-DAG: %[[VAL_20:.*]] = memref.alloca() : memref<5xindex>
+// CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_7]]] : memref<?xindex>
+// CHECK-DAG: memref.store %[[VAL_7]], %[[VAL_20]]{{\[}}%[[VAL_10]]] : memref<5xindex>
+// CHECK-DAG: memref.store %[[VAL_10]], %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<5xindex>
+// CHECK-DAG: memref.store %[[VAL_10]], %[[VAL_20]]{{\[}}%[[VAL_9]]] : memref<5xindex>
+// CHECK-DAG: memref.store %[[VAL_21]], %[[VAL_20]]{{\[}}%[[VAL_6]]] : memref<5xindex>
+// CHECK: %[[VAL_22:.*]] = arith.cmpi ugt, %[[VAL_21]], %[[VAL_10]] : index
+// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_10]]] : memref<?xindex>
+// CHECK: %[[VAL_24:.*]] = arith.cmpi uge, %[[VAL_23]], %[[VAL_6]] : index
+// CHECK: %[[VAL_25:.*]] = arith.andi %[[VAL_22]], %[[VAL_24]] : i1
+// CHECK: %[[VAL_26:.*]] = arith.addi %[[VAL_23]], %[[VAL_3]] : index
+// CHECK: %[[VAL_27:.*]] = arith.select %[[VAL_25]], %[[VAL_26]], %[[VAL_10]] : index
+// CHECK: %[[VAL_28:.*]]:3 = scf.while (%[[VAL_29:.*]] = %[[VAL_22]], %[[VAL_30:.*]] = %[[VAL_23]], %[[VAL_31:.*]] = %[[VAL_27]], %[[VAL_32:.*]] = %[[VAL_13]]) : (i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) -> (index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) {
+// CHECK: scf.condition(%[[VAL_29]]) %[[VAL_30]], %[[VAL_31]], %[[VAL_32]] : index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: } do {
-// CHECK: ^bb0(%[[VAL_32:.*]]: index, %[[VAL_33:.*]]: index, %[[VAL_34:.*]]: tensor<6x6xi32, #sparse{{[0-9]*}}>):
-// CHECK: %[[VAL_35:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_6]]] : memref<5xindex>
-// CHECK: %[[VAL_36:.*]]:4 = scf.for %[[VAL_37:.*]] = %[[VAL_8]] to %[[VAL_35]] step %[[VAL_5]] iter_args(%[[VAL_38:.*]] = %[[VAL_11]], %[[VAL_39:.*]] = %[[VAL_4]], %[[VAL_40:.*]] = %[[VAL_8]], %[[VAL_41:.*]] = %[[VAL_6]]) -> (i1, index, index, index) {
-// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_37]]] : memref<5xindex>
-// CHECK: %[[VAL_43:.*]] = arith.addi %[[VAL_37]], %[[VAL_7]] : index
-// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_43]]] : memref<5xindex>
-// CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_37]], %[[VAL_8]] : index
-// CHECK: memref.store %[[VAL_41]], %[[VAL_19]]{{\[}}%[[VAL_45]]] : memref<5xindex>
-// CHECK: %[[VAL_46:.*]] = arith.addi %[[VAL_33]], %[[VAL_5]] : index
-// CHECK: %[[VAL_47:.*]]:5 = scf.while (%[[VAL_48:.*]] = %[[VAL_42]], %[[VAL_49:.*]] = %[[VAL_38]], %[[VAL_50:.*]] = %[[VAL_39]], %[[VAL_51:.*]] = %[[VAL_40]], %[[VAL_52:.*]] = %[[VAL_41]]) : (index, i1, index, index, index) -> (index, i1, index, index, index) {
-// CHECK: %[[VAL_53:.*]] = arith.cmpi ult, %[[VAL_48]], %[[VAL_44]] : index
-// CHECK: %[[VAL_54:.*]] = scf.if %[[VAL_53]] -> (i1) {
-// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_48]]] : memref<?xindex>
-// CHECK: %[[VAL_56:.*]] = arith.cmpi ult, %[[VAL_55]], %[[VAL_46]] : index
-// CHECK: scf.yield %[[VAL_56]] : i1
+// CHECK: ^bb0(%[[VAL_33:.*]]: index, %[[VAL_34:.*]]: index, %[[VAL_35:.*]]: tensor<6x6xi32, #sparse{{[0-9]*}}>):
+// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_10]]] : memref<5xindex>
+// CHECK: %[[VAL_37:.*]]:4 = scf.for %[[VAL_38:.*]] = %[[VAL_10]] to %[[VAL_36]] step %[[VAL_7]] iter_args(%[[VAL_39:.*]] = %[[VAL_12]], %[[VAL_40:.*]] = %[[VAL_5]], %[[VAL_41:.*]] = %[[VAL_10]], %[[VAL_42:.*]] = %[[VAL_10]]) -> (i1, index, index, index) {
+// CHECK: %[[VAL_43:.*]] = arith.addi %[[VAL_38]], %[[VAL_9]] : index
+// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_43]]] : memref<5xindex>
+// CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_38]], %[[VAL_6]] : index
+// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_45]]] : memref<5xindex>
+// CHECK: %[[VAL_47:.*]] = arith.addi %[[VAL_38]], %[[VAL_4]] : index
+// CHECK: memref.store %[[VAL_42]], %[[VAL_20]]{{\[}}%[[VAL_47]]] : memref<5xindex>
+// CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_34]], %[[VAL_6]] : index
+// CHECK: %[[VAL_49:.*]]:5 = scf.while (%[[VAL_50:.*]] = %[[VAL_44]], %[[VAL_51:.*]] = %[[VAL_39]], %[[VAL_52:.*]] = %[[VAL_40]], %[[VAL_53:.*]] = %[[VAL_41]], %[[VAL_54:.*]] = %[[VAL_42]]) : (index, i1, index, index, index) -> (index, i1, index, index, index) {
+// CHECK: %[[VAL_55:.*]] = arith.cmpi ult, %[[VAL_50]], %[[VAL_46]] : index
+// CHECK: %[[VAL_56:.*]] = scf.if %[[VAL_55]] -> (i1) {
+// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_50]]] : memref<?xindex>
+// CHECK: %[[VAL_58:.*]] = arith.cmpi ult, %[[VAL_57]], %[[VAL_48]] : index
+// CHECK: scf.yield %[[VAL_58]] : i1
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_11]] : i1
+// CHECK: scf.yield %[[VAL_12]] : i1
// CHECK: }
-// CHECK: scf.condition(%[[VAL_57:.*]]) %[[VAL_48]], %[[VAL_49]], %[[VAL_50]], %[[VAL_51]], %[[VAL_52]] : index, i1, index, index, index
+// CHECK: scf.condition(%[[VAL_56]]) %[[VAL_50]], %[[VAL_51]], %[[VAL_52]], %[[VAL_53]], %[[VAL_54]] : index, i1, index, index, index
// CHECK: } do {
-// CHECK: ^bb0(%[[VAL_58:.*]]: index, %[[VAL_59:.*]]: i1, %[[VAL_60:.*]]: index, %[[VAL_61:.*]]: index, %[[VAL_62:.*]]: index):
-// CHECK: %[[VAL_63:.*]] = arith.addi %[[VAL_58]], %[[VAL_7]] : index
-// CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_58]]] : memref<?xindex>
-// CHECK: %[[VAL_65:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_63]]] : memref<?xindex>
-// CHECK: %[[VAL_66:.*]] = arith.cmpi ult, %[[VAL_64]], %[[VAL_65]] : index
-// CHECK: %[[VAL_67:.*]] = arith.ori %[[VAL_66]], %[[VAL_59]] : i1
-// CHECK: %[[VAL_68:.*]] = scf.if %[[VAL_66]] -> (index) {
-// CHECK: %[[VAL_69:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_64]]] : memref<?xindex>
-// CHECK: %[[VAL_70:.*]] = arith.cmpi ult, %[[VAL_69]], %[[VAL_60]] : index
-// CHECK: %[[VAL_71:.*]] = arith.select %[[VAL_70]], %[[VAL_69]], %[[VAL_60]] : index
-// CHECK: scf.yield %[[VAL_71]] : index
+// CHECK: ^bb0(%[[VAL_59:.*]]: index, %[[VAL_60:.*]]: i1, %[[VAL_61:.*]]: index, %[[VAL_62:.*]]: index, %[[VAL_63:.*]]: index):
+// CHECK: %[[VAL_64:.*]] = arith.addi %[[VAL_59]], %[[VAL_7]] : index
+// CHECK: %[[VAL_65:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_59]]] : memref<?xindex>
+// CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_64]]] : memref<?xindex>
+// CHECK: %[[VAL_67:.*]] = arith.cmpi ult, %[[VAL_65]], %[[VAL_66]] : index
+// CHECK: %[[VAL_68:.*]] = arith.ori %[[VAL_67]], %[[VAL_60]] : i1
+// CHECK: %[[VAL_69:.*]] = scf.if %[[VAL_67]] -> (index) {
+// CHECK: %[[VAL_70:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_65]]] : memref<?xindex>
+// CHECK: %[[VAL_71:.*]] = arith.cmpi ult, %[[VAL_70]], %[[VAL_61]] : index
+// CHECK: %[[VAL_72:.*]] = arith.select %[[VAL_71]], %[[VAL_70]], %[[VAL_61]] : index
+// CHECK: scf.yield %[[VAL_72]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_60]] : index
+// CHECK: scf.yield %[[VAL_61]] : index
// CHECK: }
-// CHECK: memref.store %[[VAL_64]], %[[VAL_18]]{{\[}}%[[VAL_61]]] : memref<11xindex>
-// CHECK: %[[VAL_72:.*]] = arith.addi %[[VAL_61]], %[[VAL_7]] : index
-// CHECK: memref.store %[[VAL_65]], %[[VAL_18]]{{\[}}%[[VAL_72]]] : memref<11xindex>
-// CHECK: %[[VAL_73:.*]] = arith.addi %[[VAL_61]], %[[VAL_5]] : index
-// CHECK: %[[VAL_74:.*]] = arith.addi %[[VAL_62]], %[[VAL_7]] : index
-// CHECK: scf.yield %[[VAL_63]], %[[VAL_67]], %[[VAL_75:.*]], %[[VAL_73]], %[[VAL_74]] : index, i1, index, index, index
+// CHECK: %[[VAL_73:.*]] = arith.addi %[[VAL_62]], %[[VAL_9]] : index
+// CHECK: memref.store %[[VAL_65]], %[[VAL_19]]{{\[}}%[[VAL_73]]] : memref<11xindex>
+// CHECK: %[[VAL_74:.*]] = arith.addi %[[VAL_62]], %[[VAL_8]] : index
+// CHECK: memref.store %[[VAL_66]], %[[VAL_19]]{{\[}}%[[VAL_74]]] : memref<11xindex>
+// CHECK: %[[VAL_75:.*]] = arith.addi %[[VAL_62]], %[[VAL_7]] : index
+// CHECK: %[[VAL_76:.*]] = arith.addi %[[VAL_63]], %[[VAL_7]] : index
+// CHECK: scf.yield %[[VAL_64]], %[[VAL_68]], %[[VAL_69]], %[[VAL_75]], %[[VAL_76]] : index, i1, index, index, index
// CHECK: }
-// CHECK: scf.yield %[[VAL_76:.*]]#1, %[[VAL_76]]#2, %[[VAL_76]]#3, %[[VAL_76]]#4 : i1, index, index, index
+// CHECK: scf.yield %[[VAL_77:.*]]#1, %[[VAL_77]]#2, %[[VAL_77]]#3, %[[VAL_77]]#4 : i1, index, index, index
// CHECK: }
-// CHECK: memref.store %[[VAL_77:.*]]#2, %[[VAL_18]]{{\[}}%[[VAL_6]]] : memref<11xindex>
-// CHECK: memref.store %[[VAL_6]], %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<11xindex>
-// CHECK: %[[VAL_78:.*]] = arith.cmpi uge, %[[VAL_77]]#1, %[[VAL_5]] : index
-// CHECK: %[[VAL_79:.*]] = arith.andi %[[VAL_77]]#0, %[[VAL_78]] : i1
-// CHECK: %[[VAL_80:.*]] = arith.addi %[[VAL_77]]#1, %[[VAL_3]] : index
-// CHECK: %[[VAL_81:.*]] = arith.select %[[VAL_79]], %[[VAL_80]], %[[VAL_6]] : index
-// CHECK: %[[VAL_82:.*]]:3 = scf.while (%[[VAL_83:.*]] = %[[VAL_77]]#0, %[[VAL_84:.*]] = %[[VAL_77]]#1, %[[VAL_85:.*]] = %[[VAL_81]], %[[VAL_86:.*]] = %[[VAL_34]]) : (i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) -> (index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) {
-// CHECK: scf.condition(%[[VAL_83]]) %[[VAL_84]], %[[VAL_85]], %[[VAL_86]] : index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: memref.store %[[VAL_78:.*]]#2, %[[VAL_19]]{{\[}}%[[VAL_10]]] : memref<11xindex>
+// CHECK: memref.store %[[VAL_10]], %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<11xindex>
+// CHECK: %[[VAL_79:.*]] = arith.cmpi uge, %[[VAL_78]]#1, %[[VAL_6]] : index
+// CHECK: %[[VAL_80:.*]] = arith.andi %[[VAL_78]]#0, %[[VAL_79]] : i1
+// CHECK: %[[VAL_81:.*]] = arith.addi %[[VAL_78]]#1, %[[VAL_3]] : index
+// CHECK: %[[VAL_82:.*]] = arith.select %[[VAL_80]], %[[VAL_81]], %[[VAL_10]] : index
+// CHECK: %[[VAL_83:.*]]:3 = scf.while (%[[VAL_84:.*]] = %[[VAL_78]]#0, %[[VAL_85:.*]] = %[[VAL_78]]#1, %[[VAL_86:.*]] = %[[VAL_82]], %[[VAL_87:.*]] = %[[VAL_35]]) : (i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) -> (index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>) {
+// CHECK: scf.condition(%[[VAL_84]]) %[[VAL_85]], %[[VAL_86]], %[[VAL_87]] : index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: } do {
-// CHECK: ^bb0(%[[VAL_87:.*]]: index, %[[VAL_88:.*]]: index, %[[VAL_89:.*]]: tensor<6x6xi32, #sparse{{[0-9]*}}>):
-// CHECK: %[[VAL_90:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<5xindex>
-// CHECK: %[[VAL_91:.*]] = arith.addi %[[VAL_90]], %[[VAL_8]] : index
-// CHECK: %[[VAL_92:.*]] = arith.addi %[[VAL_90]], %[[VAL_5]] : index
-// CHECK: %[[VAL_93:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_91]]] : memref<5xindex>
-// CHECK: %[[VAL_94:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_92]]] : memref<5xindex>
-// CHECK: %[[VAL_95:.*]] = arith.addi %[[VAL_33]], %[[VAL_5]] : index
-// CHECK: %[[VAL_96:.*]]:3 = scf.while (%[[VAL_97:.*]] = %[[VAL_93]], %[[VAL_98:.*]] = %[[VAL_10]], %[[VAL_99:.*]] = %[[VAL_11]]) : (index, i32, i1) -> (index, i32, i1) {
-// CHECK: %[[VAL_100:.*]] = arith.cmpi ult, %[[VAL_97]], %[[VAL_94]] : index
-// CHECK: %[[VAL_101:.*]] = scf.if %[[VAL_100]] -> (i1) {
-// CHECK: %[[VAL_102:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_97]]] : memref<?xindex>
-// CHECK: %[[VAL_103:.*]] = arith.cmpi ult, %[[VAL_102]], %[[VAL_95]] : index
-// CHECK: scf.yield %[[VAL_103]] : i1
+// CHECK: ^bb0(%[[VAL_88:.*]]: index, %[[VAL_89:.*]]: index, %[[VAL_90:.*]]: tensor<6x6xi32, #sparse{{[0-9]*}}>):
+// CHECK: %[[VAL_91:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<5xindex>
+// CHECK: %[[VAL_92:.*]] = arith.addi %[[VAL_91]], %[[VAL_9]] : index
+// CHECK: %[[VAL_93:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_92]]] : memref<5xindex>
+// CHECK: %[[VAL_94:.*]] = arith.addi %[[VAL_91]], %[[VAL_6]] : index
+// CHECK: %[[VAL_95:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_94]]] : memref<5xindex>
+// CHECK: %[[VAL_96:.*]] = arith.addi %[[VAL_34]], %[[VAL_6]] : index
+// CHECK: %[[VAL_97:.*]]:3 = scf.while (%[[VAL_98:.*]] = %[[VAL_93]], %[[VAL_99:.*]] = %[[VAL_11]], %[[VAL_100:.*]] = %[[VAL_12]]) : (index, i32, i1) -> (index, i32, i1) {
+// CHECK: %[[VAL_101:.*]] = arith.cmpi ult, %[[VAL_98]], %[[VAL_95]] : index
+// CHECK: %[[VAL_102:.*]] = scf.if %[[VAL_101]] -> (i1) {
+// CHECK: %[[VAL_103:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_98]]] : memref<?xindex>
+// CHECK: %[[VAL_104:.*]] = arith.cmpi ult, %[[VAL_103]], %[[VAL_96]] : index
+// CHECK: scf.yield %[[VAL_104]] : i1
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_11]] : i1
+// CHECK: scf.yield %[[VAL_12]] : i1
// CHECK: }
-// CHECK: scf.condition(%[[VAL_104:.*]]) %[[VAL_97]], %[[VAL_98]], %[[VAL_99]] : index, i32, i1
+// CHECK: scf.condition(%[[VAL_102]]) %[[VAL_98]], %[[VAL_99]], %[[VAL_100]] : index, i32, i1
// CHECK: } do {
// CHECK: ^bb0(%[[VAL_105:.*]]: index, %[[VAL_106:.*]]: i32, %[[VAL_107:.*]]: i1):
-// CHECK: %[[VAL_108:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_105]]] : memref<?xindex>
-// CHECK: %[[VAL_109:.*]] = arith.subi %[[VAL_108]], %[[VAL_33]] : index
-// CHECK: %[[VAL_110:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<11xindex>
-// CHECK: %[[VAL_111:.*]] = arith.addi %[[VAL_110]], %[[VAL_8]] : index
-// CHECK: %[[VAL_112:.*]] = arith.addi %[[VAL_110]], %[[VAL_5]] : index
-// CHECK: %[[VAL_113:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_111]]] : memref<11xindex>
-// CHECK: %[[VAL_114:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_112]]] : memref<11xindex>
-// CHECK: %[[VAL_115:.*]] = arith.addi %[[VAL_88]], %[[VAL_5]] : index
-// CHECK: %[[VAL_116:.*]]:2 = scf.while (%[[VAL_117:.*]] = %[[VAL_113]], %[[VAL_118:.*]] = %[[VAL_106]]) : (index, i32) -> (index, i32) {
+// CHECK: %[[VAL_108:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_105]]] : memref<?xindex>
+// CHECK: %[[VAL_109:.*]] = arith.subi %[[VAL_108]], %[[VAL_34]] : index
+// CHECK: %[[VAL_110:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<11xindex>
+// CHECK: %[[VAL_111:.*]] = arith.addi %[[VAL_110]], %[[VAL_9]] : index
+// CHECK: %[[VAL_112:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_111]]] : memref<11xindex>
+// CHECK: %[[VAL_113:.*]] = arith.addi %[[VAL_110]], %[[VAL_8]] : index
+// CHECK: %[[VAL_114:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_113]]] : memref<11xindex>
+// CHECK: %[[VAL_115:.*]] = arith.addi %[[VAL_89]], %[[VAL_6]] : index
+// CHECK: %[[VAL_116:.*]]:2 = scf.while (%[[VAL_117:.*]] = %[[VAL_112]], %[[VAL_118:.*]] = %[[VAL_106]]) : (index, i32) -> (index, i32) {
// CHECK: %[[VAL_119:.*]] = arith.cmpi ult, %[[VAL_117]], %[[VAL_114]] : index
// CHECK: %[[VAL_120:.*]] = scf.if %[[VAL_119]] -> (i1) {
-// CHECK: %[[VAL_121:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_117]]] : memref<?xindex>
+// CHECK: %[[VAL_121:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_117]]] : memref<?xindex>
// CHECK: %[[VAL_122:.*]] = arith.cmpi ult, %[[VAL_121]], %[[VAL_115]] : index
// CHECK: scf.yield %[[VAL_122]] : i1
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_11]] : i1
+// CHECK: scf.yield %[[VAL_12]] : i1
// CHECK: }
-// CHECK: scf.condition(%[[VAL_123:.*]]) %[[VAL_117]], %[[VAL_118]] : index, i32
+// CHECK: scf.condition(%[[VAL_120]]) %[[VAL_117]], %[[VAL_118]] : index, i32
// CHECK: } do {
-// CHECK: ^bb0(%[[VAL_124:.*]]: index, %[[VAL_125:.*]]: i32):
-// CHECK: %[[VAL_126:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_124]]] : memref<?xindex>
-// CHECK: %[[VAL_127:.*]] = arith.subi %[[VAL_126]], %[[VAL_88]] : index
-// CHECK: %[[VAL_128:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_124]]] : memref<?xi32>
-// CHECK: %[[VAL_129:.*]] = tensor.extract %[[VAL_1]]{{\[}}%[[VAL_109]], %[[VAL_127]]] : tensor<3x3xi32>
-// CHECK: %[[VAL_130:.*]] = arith.muli %[[VAL_128]], %[[VAL_129]] : i32
-// CHECK: %[[VAL_131:.*]] = arith.addi %[[VAL_125]], %[[VAL_130]] : i32
-// CHECK: %[[VAL_132:.*]] = arith.addi %[[VAL_124]], %[[VAL_7]] : index
-// CHECK: scf.yield %[[VAL_132]], %[[VAL_131]] : index, i32
+// CHECK: ^bb0(%[[VAL_123:.*]]: index, %[[VAL_124:.*]]: i32):
+// CHECK: %[[VAL_125:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_123]]] : memref<?xindex>
+// CHECK: %[[VAL_126:.*]] = arith.subi %[[VAL_125]], %[[VAL_89]] : index
+// CHECK: %[[VAL_127:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_123]]] : memref<?xi32>
+// CHECK: %[[VAL_128:.*]] = tensor.extract %[[VAL_1]]{{\[}}%[[VAL_109]], %[[VAL_126]]] : tensor<3x3xi32>
+// CHECK: %[[VAL_129:.*]] = arith.muli %[[VAL_127]], %[[VAL_128]] : i32
+// CHECK: %[[VAL_130:.*]] = arith.addi %[[VAL_124]], %[[VAL_129]] : i32
+// CHECK: %[[VAL_131:.*]] = arith.addi %[[VAL_123]], %[[VAL_7]] : index
+// CHECK: scf.yield %[[VAL_131]], %[[VAL_130]] : index, i32
// CHECK: }
-// CHECK: %[[VAL_133:.*]] = arith.addi %[[VAL_105]], %[[VAL_7]] : index
-// CHECK: memref.store %[[VAL_112]], %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<11xindex>
-// CHECK: scf.yield %[[VAL_133]], %[[VAL_136:.*]]#1, %[[VAL_2]] : index, i32, i1
+// CHECK: %[[VAL_132:.*]] = arith.addi %[[VAL_105]], %[[VAL_7]] : index
+// CHECK: %[[VAL_133:.*]] = arith.addi %[[VAL_110]], %[[VAL_7]] : index
+// CHECK: memref.store %[[VAL_133]], %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<11xindex>
+// CHECK: scf.yield %[[VAL_132]], %[[VAL_134:.*]]#1, %[[VAL_2]] : index, i32, i1
// CHECK: }
-// CHECK: %[[VAL_137:.*]] = scf.if %[[VAL_138:.*]]#2 -> (tensor<6x6xi32, #sparse{{[0-9]*}}>) {
-// CHECK: %[[VAL_139:.*]] = sparse_tensor.insert %[[VAL_138]]#1 into %[[VAL_89]]{{\[}}%[[VAL_33]], %[[VAL_88]]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
-// CHECK: scf.yield %[[VAL_139]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: %[[VAL_135:.*]] = scf.if %[[VAL_136:.*]]#2 -> (tensor<6x6xi32, #sparse{{[0-9]*}}>) {
+// CHECK: %[[VAL_137:.*]] = sparse_tensor.insert %[[VAL_136]]#1 into %[[VAL_90]]{{\[}}%[[VAL_34]], %[[VAL_89]]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: scf.yield %[[VAL_137]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_89]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: scf.yield %[[VAL_90]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: }
-// CHECK: memref.store %[[VAL_6]], %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<5xindex>
-// CHECK: memref.store %[[VAL_6]], %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<11xindex>
-// CHECK: %[[VAL_140:.*]] = arith.cmpi ugt, %[[VAL_87]], %[[VAL_88]] : index
-// CHECK: %[[VAL_141:.*]]:3 = scf.if %[[VAL_140]] -> (index, i1, index) {
-// CHECK: %[[VAL_142:.*]] = arith.addi %[[VAL_88]], %[[VAL_7]] : index
-// CHECK: scf.yield %[[VAL_87]], %[[VAL_2]], %[[VAL_142]] : index, i1, index
+// CHECK: memref.store %[[VAL_10]], %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<5xindex>
+// CHECK: memref.store %[[VAL_10]], %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<11xindex>
+// CHECK: %[[VAL_138:.*]] = arith.cmpi ugt, %[[VAL_88]], %[[VAL_89]] : index
+// CHECK: %[[VAL_139:.*]]:3 = scf.if %[[VAL_138]] -> (index, i1, index) {
+// CHECK: %[[VAL_140:.*]] = arith.addi %[[VAL_89]], %[[VAL_7]] : index
+// CHECK: scf.yield %[[VAL_88]], %[[VAL_2]], %[[VAL_140]] : index, i1, index
// CHECK: } else {
-// CHECK: %[[VAL_143:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_6]]] : memref<11xindex>
-// CHECK: %[[VAL_144:.*]]:2 = scf.for %[[VAL_145:.*]] = %[[VAL_8]] to %[[VAL_143]] step %[[VAL_5]] iter_args(%[[VAL_146:.*]] = %[[VAL_4]], %[[VAL_147:.*]] = %[[VAL_11]]) -> (index, i1) {
-// CHECK: %[[VAL_148:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_145]]] : memref<11xindex>
-// CHECK: %[[VAL_149:.*]] = arith.addi %[[VAL_145]], %[[VAL_7]] : index
-// CHECK: %[[VAL_150:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_149]]] : memref<11xindex>
-// CHECK: %[[VAL_151:.*]] = arith.cmpi ult, %[[VAL_148]], %[[VAL_150]] : index
-// CHECK: %[[VAL_152:.*]] = scf.if %[[VAL_151]] -> (index) {
-// CHECK: %[[VAL_153:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_148]]] : memref<?xindex>
-// CHECK: %[[VAL_154:.*]] = arith.cmpi eq, %[[VAL_153]], %[[VAL_87]] : index
-// CHECK: %[[VAL_155:.*]] = scf.if %[[VAL_154]] -> (index) {
-// CHECK: %[[VAL_156:.*]] = arith.addi %[[VAL_148]], %[[VAL_7]] : index
-// CHECK: memref.store %[[VAL_156]], %[[VAL_18]]{{\[}}%[[VAL_145]]] : memref<11xindex>
-// CHECK: scf.yield %[[VAL_156]] : index
+// CHECK: %[[VAL_141:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_10]]] : memref<11xindex>
+// CHECK: %[[VAL_142:.*]]:2 = scf.for %[[VAL_143:.*]] = %[[VAL_10]] to %[[VAL_141]] step %[[VAL_7]] iter_args(%[[VAL_144:.*]] = %[[VAL_5]], %[[VAL_145:.*]] = %[[VAL_12]]) -> (index, i1) {
+// CHECK: %[[VAL_146:.*]] = arith.addi %[[VAL_143]], %[[VAL_9]] : index
+// CHECK: %[[VAL_147:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_146]]] : memref<11xindex>
+// CHECK: %[[VAL_148:.*]] = arith.addi %[[VAL_143]], %[[VAL_8]] : index
+// CHECK: %[[VAL_149:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_148]]] : memref<11xindex>
+// CHECK: %[[VAL_150:.*]] = arith.cmpi ult, %[[VAL_147]], %[[VAL_149]] : index
+// CHECK: %[[VAL_151:.*]] = scf.if %[[VAL_150]] -> (index) {
+// CHECK: %[[VAL_152:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_147]]] : memref<?xindex>
+// CHECK: %[[VAL_153:.*]] = arith.cmpi eq, %[[VAL_152]], %[[VAL_88]] : index
+// CHECK: %[[VAL_154:.*]] = scf.if %[[VAL_153]] -> (index) {
+// CHECK: %[[VAL_155:.*]] = arith.addi %[[VAL_147]], %[[VAL_7]] : index
+// CHECK: memref.store %[[VAL_155]], %[[VAL_19]]{{\[}}%[[VAL_146]]] : memref<11xindex>
+// CHECK: scf.yield %[[VAL_155]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_148]] : index
+// CHECK: scf.yield %[[VAL_147]] : index
// CHECK: }
-// CHECK: scf.yield %[[VAL_157:.*]] : index
+// CHECK: scf.yield %[[VAL_154]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_148]] : index
+// CHECK: scf.yield %[[VAL_147]] : index
// CHECK: }
-// CHECK: %[[VAL_158:.*]] = arith.cmpi ult, %[[VAL_159:.*]], %[[VAL_150]] : index
-// CHECK: %[[VAL_160:.*]] = scf.if %[[VAL_158]] -> (index) {
-// CHECK: %[[VAL_161:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_159]]] : memref<?xindex>
-// CHECK: scf.yield %[[VAL_161]] : index
+// CHECK: %[[VAL_156:.*]] = arith.cmpi ult, %[[VAL_151]], %[[VAL_149]] : index
+// CHECK: %[[VAL_157:.*]] = scf.if %[[VAL_156]] -> (index) {
+// CHECK: %[[VAL_158:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_151]]] : memref<?xindex>
+// CHECK: scf.yield %[[VAL_158]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_146]] : index
+// CHECK: scf.yield %[[VAL_144]] : index
// CHECK: }
-// CHECK: %[[VAL_162:.*]] = arith.ori %[[VAL_158]], %[[VAL_147]] : i1
-// CHECK: %[[VAL_163:.*]] = arith.cmpi ult, %[[VAL_164:.*]], %[[VAL_146]] : index
-// CHECK: %[[VAL_165:.*]] = arith.select %[[VAL_163]], %[[VAL_164]], %[[VAL_146]] : index
-// CHECK: scf.yield %[[VAL_165]], %[[VAL_162]] : index, i1
+// CHECK: %[[VAL_159:.*]] = arith.ori %[[VAL_156]], %[[VAL_145]] : i1
+// CHECK: %[[VAL_160:.*]] = arith.cmpi ult, %[[VAL_157]], %[[VAL_144]] : index
+// CHECK: %[[VAL_161:.*]] = arith.select %[[VAL_160]], %[[VAL_157]], %[[VAL_144]] : index
+// CHECK: scf.yield %[[VAL_161]], %[[VAL_159]] : index, i1
// CHECK: }
-// CHECK: %[[VAL_166:.*]] = arith.addi %[[VAL_167:.*]]#0, %[[VAL_7]] : index
-// CHECK: %[[VAL_168:.*]] = arith.addi %[[VAL_167]]#0, %[[VAL_3]] : index
-// CHECK: %[[VAL_169:.*]] = arith.cmpi uge, %[[VAL_166]], %[[VAL_5]] : index
-// CHECK: %[[VAL_170:.*]] = arith.select %[[VAL_169]], %[[VAL_168]], %[[VAL_6]] : index
-// CHECK: scf.yield %[[VAL_167]]#0, %[[VAL_167]]#1, %[[VAL_170]] : index, i1, index
+// CHECK: %[[VAL_162:.*]] = arith.addi %[[VAL_163:.*]]#0, %[[VAL_7]] : index
+// CHECK: %[[VAL_164:.*]] = arith.addi %[[VAL_163]]#0, %[[VAL_3]] : index
+// CHECK: %[[VAL_165:.*]] = arith.cmpi uge, %[[VAL_162]], %[[VAL_6]] : index
+// CHECK: %[[VAL_166:.*]] = arith.select %[[VAL_165]], %[[VAL_164]], %[[VAL_10]] : index
+// CHECK: scf.yield %[[VAL_163]]#0, %[[VAL_163]]#1, %[[VAL_166]] : index, i1, index
// CHECK: }
-// CHECK: %[[VAL_171:.*]] = arith.addi %[[VAL_88]], %[[VAL_7]] : index
-// CHECK: %[[VAL_172:.*]] = arith.cmpi ugt, %[[VAL_173:.*]]#2, %[[VAL_171]] : index
-// CHECK: %[[VAL_174:.*]] = arith.select %[[VAL_172]], %[[VAL_173]]#2, %[[VAL_171]] : index
-// CHECK: %[[VAL_175:.*]] = arith.addi %[[VAL_174]], %[[VAL_5]] : index
-// CHECK: %[[VAL_176:.*]] = arith.cmpi ule, %[[VAL_175]], %[[VAL_4]] : index
-// CHECK: %[[VAL_177:.*]] = arith.andi %[[VAL_173]]#1, %[[VAL_176]] : i1
-// CHECK: scf.yield %[[VAL_177]], %[[VAL_173]]#0, %[[VAL_174]], %[[VAL_178:.*]] : i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: %[[VAL_167:.*]] = arith.addi %[[VAL_89]], %[[VAL_7]] : index
+// CHECK: %[[VAL_168:.*]] = arith.cmpi ugt, %[[VAL_169:.*]]#2, %[[VAL_167]] : index
+// CHECK: %[[VAL_170:.*]] = arith.select %[[VAL_168]], %[[VAL_169]]#2, %[[VAL_167]] : index
+// CHECK: %[[VAL_171:.*]] = arith.addi %[[VAL_170]], %[[VAL_6]] : index
+// CHECK: %[[VAL_172:.*]] = arith.cmpi ule, %[[VAL_171]], %[[VAL_5]] : index
+// CHECK: %[[VAL_173:.*]] = arith.andi %[[VAL_169]]#1, %[[VAL_172]] : i1
+// CHECK: scf.yield %[[VAL_173]], %[[VAL_169]]#0, %[[VAL_170]], %[[VAL_135]] : i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: }
-// CHECK: memref.store %[[VAL_6]], %[[VAL_19]]{{\[}}%[[VAL_7]]] : memref<5xindex>
-// CHECK: %[[VAL_179:.*]] = arith.cmpi ugt, %[[VAL_32]], %[[VAL_33]] : index
-// CHECK: %[[VAL_180:.*]]:3 = scf.if %[[VAL_179]] -> (index, i1, index) {
-// CHECK: %[[VAL_181:.*]] = arith.addi %[[VAL_33]], %[[VAL_7]] : index
-// CHECK: scf.yield %[[VAL_32]], %[[VAL_2]], %[[VAL_181]] : index, i1, index
+// CHECK: memref.store %[[VAL_10]], %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<5xindex>
+// CHECK: %[[VAL_174:.*]] = arith.cmpi ugt, %[[VAL_33]], %[[VAL_34]] : index
+// CHECK: %[[VAL_175:.*]]:3 = scf.if %[[VAL_174]] -> (index, i1, index) {
+// CHECK: %[[VAL_176:.*]] = arith.addi %[[VAL_34]], %[[VAL_7]] : index
+// CHECK: scf.yield %[[VAL_33]], %[[VAL_2]], %[[VAL_176]] : index, i1, index
// CHECK: } else {
-// CHECK: %[[VAL_182:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_6]]] : memref<5xindex>
-// CHECK: %[[VAL_183:.*]]:2 = scf.for %[[VAL_184:.*]] = %[[VAL_8]] to %[[VAL_182]] step %[[VAL_5]] iter_args(%[[VAL_185:.*]] = %[[VAL_4]], %[[VAL_186:.*]] = %[[VAL_11]]) -> (index, i1) {
-// CHECK: %[[VAL_187:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_184]]] : memref<5xindex>
-// CHECK: %[[VAL_188:.*]] = arith.addi %[[VAL_184]], %[[VAL_7]] : index
-// CHECK: %[[VAL_189:.*]] = memref.load %[[VAL_19]]{{\[}}%[[VAL_188]]] : memref<5xindex>
-// CHECK: %[[VAL_190:.*]] = arith.cmpi ult, %[[VAL_187]], %[[VAL_189]] : index
-// CHECK: %[[VAL_191:.*]] = scf.if %[[VAL_190]] -> (index) {
-// CHECK: %[[VAL_192:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_187]]] : memref<?xindex>
-// CHECK: %[[VAL_193:.*]] = arith.cmpi eq, %[[VAL_192]], %[[VAL_32]] : index
-// CHECK: %[[VAL_194:.*]] = scf.if %[[VAL_193]] -> (index) {
-// CHECK: %[[VAL_195:.*]] = arith.addi %[[VAL_187]], %[[VAL_7]] : index
-// CHECK: memref.store %[[VAL_195]], %[[VAL_19]]{{\[}}%[[VAL_184]]] : memref<5xindex>
-// CHECK: scf.yield %[[VAL_195]] : index
+// CHECK: %[[VAL_177:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_10]]] : memref<5xindex>
+// CHECK: %[[VAL_178:.*]]:2 = scf.for %[[VAL_179:.*]] = %[[VAL_10]] to %[[VAL_177]] step %[[VAL_7]] iter_args(%[[VAL_180:.*]] = %[[VAL_5]], %[[VAL_181:.*]] = %[[VAL_12]]) -> (index, i1) {
+// CHECK: %[[VAL_182:.*]] = arith.addi %[[VAL_179]], %[[VAL_9]] : index
+// CHECK: %[[VAL_183:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_182]]] : memref<5xindex>
+// CHECK: %[[VAL_184:.*]] = arith.addi %[[VAL_179]], %[[VAL_6]] : index
+// CHECK: %[[VAL_185:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_184]]] : memref<5xindex>
+// CHECK: %[[VAL_186:.*]] = arith.cmpi ult, %[[VAL_183]], %[[VAL_185]] : index
+// CHECK: %[[VAL_187:.*]] = scf.if %[[VAL_186]] -> (index) {
+// CHECK: %[[VAL_188:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_183]]] : memref<?xindex>
+// CHECK: %[[VAL_189:.*]] = arith.cmpi eq, %[[VAL_188]], %[[VAL_33]] : index
+// CHECK: %[[VAL_190:.*]] = scf.if %[[VAL_189]] -> (index) {
+// CHECK: %[[VAL_191:.*]] = arith.addi %[[VAL_183]], %[[VAL_7]] : index
+// CHECK: memref.store %[[VAL_191]], %[[VAL_20]]{{\[}}%[[VAL_182]]] : memref<5xindex>
+// CHECK: scf.yield %[[VAL_191]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_187]] : index
+// CHECK: scf.yield %[[VAL_183]] : index
// CHECK: }
-// CHECK: scf.yield %[[VAL_196:.*]] : index
+// CHECK: scf.yield %[[VAL_190]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_187]] : index
+// CHECK: scf.yield %[[VAL_183]] : index
// CHECK: }
-// CHECK: %[[VAL_197:.*]] = arith.cmpi ult, %[[VAL_198:.*]], %[[VAL_189]] : index
-// CHECK: %[[VAL_199:.*]] = scf.if %[[VAL_197]] -> (index) {
-// CHECK: %[[VAL_200:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_198]]] : memref<?xindex>
-// CHECK: scf.yield %[[VAL_200]] : index
+// CHECK: %[[VAL_192:.*]] = arith.cmpi ult, %[[VAL_187]], %[[VAL_185]] : index
+// CHECK: %[[VAL_193:.*]] = scf.if %[[VAL_192]] -> (index) {
+// CHECK: %[[VAL_194:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_187]]] : memref<?xindex>
+// CHECK: scf.yield %[[VAL_194]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_185]] : index
+// CHECK: scf.yield %[[VAL_180]] : index
// CHECK: }
-// CHECK: %[[VAL_201:.*]] = arith.ori %[[VAL_197]], %[[VAL_186]] : i1
-// CHECK: %[[VAL_202:.*]] = arith.cmpi ult, %[[VAL_203:.*]], %[[VAL_185]] : index
-// CHECK: %[[VAL_204:.*]] = arith.select %[[VAL_202]], %[[VAL_203]], %[[VAL_185]] : index
-// CHECK: scf.yield %[[VAL_204]], %[[VAL_201]] : index, i1
+// CHECK: %[[VAL_195:.*]] = arith.ori %[[VAL_192]], %[[VAL_181]] : i1
+// CHECK: %[[VAL_196:.*]] = arith.cmpi ult, %[[VAL_193]], %[[VAL_180]] : index
+// CHECK: %[[VAL_197:.*]] = arith.select %[[VAL_196]], %[[VAL_193]], %[[VAL_180]] : index
+// CHECK: scf.yield %[[VAL_197]], %[[VAL_195]] : index, i1
// CHECK: }
-// CHECK: %[[VAL_205:.*]] = arith.addi %[[VAL_206:.*]]#0, %[[VAL_7]] : index
-// CHECK: %[[VAL_207:.*]] = arith.addi %[[VAL_206]]#0, %[[VAL_3]] : index
-// CHECK: %[[VAL_208:.*]] = arith.cmpi uge, %[[VAL_205]], %[[VAL_5]] : index
-// CHECK: %[[VAL_209:.*]] = arith.select %[[VAL_208]], %[[VAL_207]], %[[VAL_6]] : index
-// CHECK: scf.yield %[[VAL_206]]#0, %[[VAL_206]]#1, %[[VAL_209]] : index, i1, index
+// CHECK: %[[VAL_198:.*]] = arith.addi %[[VAL_199:.*]]#0, %[[VAL_7]] : index
+// CHECK: %[[VAL_200:.*]] = arith.addi %[[VAL_199]]#0, %[[VAL_3]] : index
+// CHECK: %[[VAL_201:.*]] = arith.cmpi uge, %[[VAL_198]], %[[VAL_6]] : index
+// CHECK: %[[VAL_202:.*]] = arith.select %[[VAL_201]], %[[VAL_200]], %[[VAL_10]] : index
+// CHECK: scf.yield %[[VAL_199]]#0, %[[VAL_199]]#1, %[[VAL_202]] : index, i1, index
// CHECK: }
-// CHECK: %[[VAL_210:.*]] = arith.addi %[[VAL_33]], %[[VAL_7]] : index
-// CHECK: %[[VAL_211:.*]] = arith.cmpi ugt, %[[VAL_212:.*]]#2, %[[VAL_210]] : index
-// CHECK: %[[VAL_213:.*]] = arith.select %[[VAL_211]], %[[VAL_212]]#2, %[[VAL_210]] : index
-// CHECK: %[[VAL_214:.*]] = arith.addi %[[VAL_213]], %[[VAL_5]] : index
-// CHECK: %[[VAL_215:.*]] = arith.cmpi ule, %[[VAL_214]], %[[VAL_4]] : index
-// CHECK: %[[VAL_216:.*]] = arith.andi %[[VAL_212]]#1, %[[VAL_215]] : i1
-// CHECK: scf.yield %[[VAL_216]], %[[VAL_212]]#0, %[[VAL_213]], %[[VAL_217:.*]]#2 : i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: %[[VAL_203:.*]] = arith.addi %[[VAL_34]], %[[VAL_7]] : index
+// CHECK: %[[VAL_204:.*]] = arith.cmpi ugt, %[[VAL_205:.*]]#2, %[[VAL_203]] : index
+// CHECK: %[[VAL_206:.*]] = arith.select %[[VAL_204]], %[[VAL_205]]#2, %[[VAL_203]] : index
+// CHECK: %[[VAL_207:.*]] = arith.addi %[[VAL_206]], %[[VAL_6]] : index
+// CHECK: %[[VAL_208:.*]] = arith.cmpi ule, %[[VAL_207]], %[[VAL_5]] : index
+// CHECK: %[[VAL_209:.*]] = arith.andi %[[VAL_205]]#1, %[[VAL_208]] : i1
+// CHECK: scf.yield %[[VAL_209]], %[[VAL_205]]#0, %[[VAL_206]], %[[VAL_210:.*]]#2 : i1, index, index, tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: }
-// CHECK: %[[VAL_218:.*]] = sparse_tensor.load %[[VAL_219:.*]]#2 hasInserts : tensor<6x6xi32, #sparse{{[0-9]*}}>
-// CHECK: return %[[VAL_218]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: %[[VAL_211:.*]] = sparse_tensor.load %[[VAL_212:.*]]#2 hasInserts : tensor<6x6xi32, #sparse{{[0-9]*}}>
+// CHECK: return %[[VAL_211]] : tensor<6x6xi32, #sparse{{[0-9]*}}>
// CHECK: }
func.func @conv2d_all_sparse_CSR(%arg0: tensor<8x8xi32, #DCSR>,
%arg1: tensor<3x3xi32>) -> tensor<6x6xi32, #DCSR> {
More information about the Mlir-commits
mailing list