[mlir][tensor/memref] Replace various redundant helpers with `reifyShapeDims`

[springerm]

Summary

Depends On: D146052

[springerm]

Note: This revision is separate from D146052 because it contains mostly cases where the exact type of the shaped value is known. I.e., in most cases we know whether a tensor.dim or a memref.dim should be generated. Going through reifyShapeDims saves a few lines of code each time, but it also goes through the interface method each time (which has some overhead). It's a tradeoff. Therefore, putting these change separately.

(We could still de-duplicate some parts of the code base a bit, even if we don't go the interface.)

[aartbik]

LG for sparse with one nit

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

121

please use

for (int64_t dim = 0, rank = getRank(); dim < rank; ++dim)

idiom we always use in sparse compiler module

[mehdi_amini]

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

121

If you like functional style, you also have: for (int64_t dim : llvm::seq(0, getRank())) :)

[mravishankar]

This looks good to me. I am approving this change. I dont have comments on the depedent patch though. If that is good, this is good for me.

mlir/include/mlir/Dialect/Bufferization/IR/Bufferization.h

 #include "mlir/Dialect/Bufferization/IR/BufferizationOps.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Helper functions
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace bufferization {
-/// Populate `dynamicDims` with tensor::DimOp / memref::DimOp results for all
-/// dynamic dimensions of the given shaped value.
-void populateDynamicDimSizes(OpBuilder &b, Location loc, Value shapedValue,
-                             SmallVector<Value> &dynamicDims);
-
 /// Try to cast the given ranked MemRef-typed value to the given ranked MemRef
 /// type. Insert a reallocation + copy if it cannot be statically guaranteed
 /// that a direct cast would be valid.
 ///
 /// E.g., when casting from a ranked MemRef type with dynamic layout to a ranked
 /// MemRef type with static layout, it is not statically known whether the cast
 /// will succeed or not. Such `memref.cast` ops may fail at runtime. This
 /// function never generates such casts and conservatively inserts a copy.

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

 bool isElementwise(LinalgOp op);
 
 /// Check if iterator type has "parallel" semantics.
 bool isParallelIterator(utils::IteratorType iteratorType);
 
 /// Check if iterator type  has "reduction" semantics.
 bool isReductionIterator(utils::IteratorType iteratorType);
 
-/// Given an operation, retrieves the value of each dynamic dimension through
-/// constructing the necessary DimOp operators.
-SmallVector<Value, 4> getDynOperands(Location loc, Value val, OpBuilder &b);
-
 /// Computes an upper bound for the result `value` of an index computation.
 /// Translates AffineMinOps and AffineApplyOps along the use-def chains of the
 /// index computation to affine constraints and projects out intermediate
 /// values. The method sets `boundMap` to an affine map that given
 /// `boundOperands` evaluates to an upper bound for the index computation.
 ///
 /// If constantRequired is true, only returns the constant bounds (potentially
 /// over-approximating) and fails when not possible.

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

 /// type.
 Type getTensorTypeFromMemRefType(Type type);
 
 /// Finds a single dealloc operation for the given allocated value. If there
 /// are > 1 deallocates for `allocValue`, returns std::nullopt, else returns the
 /// single deallocate if it exists or nullptr.
 std::optional<Operation *> findDealloc(Value allocValue);
 
-/// Return the dimensions of the given memref value.
-SmallVector<OpFoldResult> getMixedSizes(OpBuilder &builder, Location loc,
-                                        Value value);
-
 /// Create a rank-reducing SubViewOp @[0 .. 0] with strides [1 .. 1] and
 /// appropriate sizes (i.e. `memref.getSizes()`) to reduce the rank of `memref`
 /// to that of `targetShape`.
 Value createCanonicalRankReducingSubViewOp(OpBuilder &b, Location loc,
                                            Value memref,
                                            ArrayRef<int64_t> targetShape);
 } // namespace memref
 } // namespace mlir

mlir/include/mlir/Dialect/Tensor/IR/Tensor.h

 /// Not all ops might be canonicalizable this way, but for those that can be,
 /// this method provides a check that it is worth doing the canonicalization.
 bool canFoldIntoProducerOp(CastOp castOp);
 
 /// Performs folding of any operand of `op` if it comes from a tensor::CastOp
 /// that can be folded.
 LogicalResult foldTensorCast(Operation *op);
 
-/// Return the dimensions of the given tensor value.
-SmallVector<OpFoldResult> getMixedSizes(OpBuilder &builder, Location loc,
-                                        Value value);
-
 /// Create a rank-reducing ExtractSliceOp @[0 .. 0] with strides [1 .. 1] and
 /// appropriate sizes (i.e. `tensor.getSizes()`) to reduce the rank of `tensor`
 /// to that of `targetType`.
 Value createCanonicalRankReducingExtractSliceOp(OpBuilder &b, Location loc,
                                                 Value tensor,
                                                 RankedTensorType targetType);
 
 /// Create a rank-reducing InsertSliceOp @[0 .. 0] with strides [1 .. 1] and

mlir/include/mlir/Dialect/Tensor/Utils/Utils.h

 
 // Return a PadOp that pads `source` to `type` size where the static
 // sizes are assumed to be greater than the dynamic sizes. If `type` has dynamic
 // dimensions the padding width is set to zero. The op performs "high" padding
 // (i.e. it adds trailing padding values until the desired size is met).
 PadOp createPadHighOp(RankedTensorType type, Value source, Value pad,
                       bool nofold, Location loc, OpBuilder &builder);
 
-// Creates dim ops for each dynamic dimension of the ranked tensor argument and
-// returns these as values.
-SmallVector<Value> createDynamicDimValues(OpBuilder &b, Location loc,
-                                          Value rankedTensor);
-
-// Creates dim ops or constant ops for each dimension of the ranked tensor
-// argument and returns these as values.
-SmallVector<OpFoldResult> createDimValues(OpBuilder &b, Location loc,
-                                          Value rankedTensor);
-
 /// Returns the transposed `rankedTensorType` if `transposeVector` is non-empty.
 /// Fail if `transposeVector` is not a permutation matching the tensor rank.
 FailureOr<RankedTensorType>
 computeTransposedType(RankedTensorType rankedTensorType,
                       ArrayRef<int64_t> transposeVector);
 
 } // namespace tensor
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TENSOR_UTILS_UTILS_H_

mlir/include/mlir/Interfaces/ShapedTypeInterfaces.h

 //===- ShapedTypeInterfaces.h - Interfaces for Shaped Types -----*- C++ -*-===//
 //
 // 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 contains a set of interfaces for shaped types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INTERFACES_SHAPEDTYPEINTERFACES_H_
 #define MLIR_INTERFACES_SHAPEDTYPEINTERFACES_H_
 
 #include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/SmallVector.h"
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/ShapedTypeInterfaces.h.inc"
 
 namespace mlir {
 
 /// Reify the specified dimension of the given shaped value. This function
 /// returns an IntegerAttr if `dim` is a constant and the respective dimension
 /// is static. Otherwise, it returns a Value.
 OpFoldResult reifyShapeDim(OpBuilder &builder, Location loc, Value shapedValue,
                            OpFoldResult dim);
 
 /// Reify the specified dimension of the given shaped value. This function
 /// returns an IntegerAttr if the dimension size is static. Otherwise, it
 /// returns a Value.
 OpFoldResult reifyShapeDim(OpBuilder &builder, Location loc, Value shapedValue,
                            int64_t dim);
 
+/// Reify all dimensions of the given shaped value. The shape value must have a
+/// statically known rank. This function returns an IntegerAttr for each static
+/// dimension size. Otherwise, it returns a Value.
+SmallVector<OpFoldResult> reifyShapeDims(OpBuilder &builder, Location loc,
+                                         Value shapedValue);
+
+/// Reify all dynamic dimensions of the given shaped value. The shape value must
+/// have a statically known rank.
+SmallVector<Value> reifyDynamicShapeDims(OpBuilder &builder, Location loc,
+                                         Value shapedValue);
+
 } // namespace mlir
 
 #endif // MLIR_INTERFACES_SHAPEDTYPEINTERFACES_H_

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "llvm/Support/Debug.h"
 
 //===----------------------------------------------------------------------===//
 // BufferizableOpInterface
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace bufferization {
if (shapedValue.getType().isa<RankedTensorType>() &&
         for (const auto &dim : enumerate(tensorType.getShape()))
           if (ShapedType::isDynamic(dim.value()))
             dynamicSizes.push_back(shape[dim.index()].get<Value>());
       }
     }
 
     // If the shape could not be reified, create DimOps.
     if (!reifiedShapes)
-      populateDynamicDimSizes(b, loc, tensor, dynamicSizes);
+      dynamicSizes = reifyDynamicShapeDims(b, loc, tensor);
   }
 
   // Create AllocTensorOp.
   auto allocTensorOp = b.create<AllocTensorOp>(loc, tensorType, dynamicSizes,
                                                copy ? tensor : Value());
   allocTensorOp->setAttr(BufferizationDialect::kEscapeAttrName,
                          b.getBoolArrayAttr({escape}));
 

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
 #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/Matchers.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include <optional>
 
 using namespace mlir;
 using namespace mlir::bufferization;
 
 //===----------------------------------------------------------------------===//
 // Helper functions
 //===----------------------------------------------------------------------===//
mlir::bufferization::foldToMemrefToTensorPair(RewriterBase &rewriter,
   // Ranked memref -> unranked memref cast: No copy needed.
   assert(memref::CastOp::areCastCompatible(srcType, destType) &&
          "expected that types are cast compatible");
   rewriter.replaceOpWithNewOp<memref::CastOp>(toMemref, destType,
                                               memrefToTensor.getMemref());
   return success();
 }
 
-void mlir::bufferization::populateDynamicDimSizes(
-    OpBuilder &b, Location loc, Value shapedValue,
-    SmallVector<Value> &dynamicDims) {
-  auto shapedType = shapedValue.getType().cast<ShapedType>();
-  for (int64_t i = 0; i < shapedType.getRank(); ++i) {
-    if (shapedType.isDynamicDim(i)) {
-      if (shapedType.isa<MemRefType>()) {
-        dynamicDims.push_back(b.create<memref::DimOp>(loc, shapedValue, i));
-      } else {
-        assert(shapedType.isa<RankedTensorType>() && "expected tensor");
-        dynamicDims.push_back(b.create<tensor::DimOp>(loc, shapedValue, i));
-      }
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // AllocTensorOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult AllocTensorOp::bufferize(RewriterBase &rewriter,
                                        const BufferizationOptions &options) {
   OpBuilder::InsertionGuard g(rewriter);
   Location loc = getLoc();
LogicalResult AllocTensorOp::bufferize(RewriterBase &rewriter,
 
   // Create memory allocation.
   auto allocType = bufferization::getBufferType(getResult(), options);
   if (failed(allocType))
     return failure();
   SmallVector<Value> dynamicDims = getDynamicSizes();
   if (getCopy()) {
     assert(dynamicDims.empty() && "expected either `copy` or `dynamicDims`");
-    populateDynamicDimSizes(rewriter, loc, copyBuffer, dynamicDims);
+    dynamicDims = reifyDynamicShapeDims(rewriter, loc, copyBuffer);
   }
   FailureOr<Value> alloc = options.createAlloc(
       rewriter, loc, allocType->cast<MemRefType>(), dynamicDims);
   if (failed(alloc))
     return failure();
 
   // Create memory copy (if any).
   if (getCopy()) {

mlir/lib/Dialect/Bufferization/IR/CMakeLists.txt

add_mlir_dialect_library(MLIRBufferizationDialect
   MLIRBufferizationEnumsIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffineDialect
   MLIRDestinationStyleOpInterface
   MLIRDialect
   MLIRFuncDialect
   MLIRIR
+  MLIRShapedTypeInterfaces
   MLIRSparseTensorDialect
   MLIRTensorDialect
   MLIRMemRefDialect
   )

mlir/lib/Dialect/Linalg/TransformOps/CMakeLists.txt

add_mlir_dialect_library(MLIRLinalgTransformOps
   MLIRArithDialect
   MLIRFuncDialect
   MLIRIR
   MLIRLinalgDialect
   MLIRLinalgTransforms
   MLIRParser
   MLIRPDLDialect
   MLIRSCFDialect
+  MLIRShapedTypeInterfaces
   MLIRSideEffectInterfaces
   MLIRTransformDialect
   MLIRTransformDialectUtils
   MLIRVectorDialect
   )

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

 #include "mlir/Dialect/Transform/Utils/Utils.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Interfaces/TilingInterface.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSet.h"
static FailureOr<LowerUnPackOpResult> lowerUnPack(RewriterBase &rewriter,
 
   // 6. ExtractSlice
   auto destTensorType = unPackOp.getDest().getType().cast<RankedTensorType>();
   int64_t destRank = destTensorType.getRank();
   OpFoldResult zero = rewriter.getIndexAttr(0), one = rewriter.getIndexAttr(1);
   auto extractSliceOp = rewriter.create<tensor::ExtractSliceOp>(
       loc, destTensorType, reshapeOp->getResult(0),
       SmallVector<OpFoldResult>(destRank, zero),
-      tensor::getMixedSizes(rewriter, loc, unPackOp->getResult(0)),
+      reifyShapeDims(rewriter, loc, unPackOp->getResult(0)),
       SmallVector<OpFoldResult>(destRank, one));
 
   // 7. Replace unPackOp by transposeOp.
   rewriter.replaceOp(unPackOp, extractSliceOp->getResults());
 
   return LowerUnPackOpResult{emptyOp, transposeOp, reshapeOp, extractSliceOp};
 }
 

mlir/lib/Dialect/Linalg/Transforms/ConvertToDestinationStyle.cpp

 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
 using namespace mlir::tensor;
 
 // Implements backtracking to traverse indices of the output buffer while
 // iterating over op.elements().
Value linalg::bufferizeToAllocation(RewriterBase &rewriter, PadOp padOp,
   rewriter.setInsertionPointAfter(alloc.getDefiningOp());
 
   // Create linalg.fill or linalg.generic.
   Operation *fillOp = movePaddingToFillOrGenericOp(rewriter, loc, padOp, alloc);
   rewriter.setInsertionPointAfter(fillOp);
 
   // Create memref.tensor_store.
   SmallVector<OpFoldResult> sizes =
-      getMixedSizes(rewriter, loc, padOp.getSource());
+      reifyShapeDims(rewriter, loc, padOp.getSource());
   SmallVector<OpFoldResult> strides(padOp.getResultType().getRank(),
                                     rewriter.getIndexAttr(1));
   Value subview = rewriter.create<memref::SubViewOp>(
       loc, alloc, /*offsets=*/padOp.getMixedLowPad(), sizes, strides);
   rewriter.create<memref::TensorStoreOp>(loc, padOp.getSource(), subview);
 
   // Create bufferization.to_tensor with "restrict" and "writable". The returned
   // tensor is a new buffer allocation, so it does not alias with any buffer.
mlir::linalg::rewriteInDestinationPassingStyle(RewriterBase &rewriter,
 
   Value empty = rewriter.create<EmptyOp>(loc, resultType, dynamicSizes);
   // Create linalg.fill or linalg.generic.
   Operation *fillOp = movePaddingToFillOrGenericOp(rewriter, loc, padOp, empty);
   rewriter.setInsertionPointAfter(fillOp);
 
   // Create tensor::InsertSliceOp.
   SmallVector<OpFoldResult> sliceSizes =
-      getMixedSizes(rewriter, loc, padOp.getSource());
+      reifyShapeDims(rewriter, loc, padOp.getSource());
   SmallVector<OpFoldResult> sliceStrides(resultType.getRank(),
                                          rewriter.getIndexAttr(1));
   auto insertSliceOp = rewriter.replaceOpWithNewOp<tensor::InsertSliceOp>(
       padOp, padOp.getSource(), fillOp->getResult(0),
       /*offsets=*/padOp.getMixedLowPad(), sliceSizes, sliceStrides);
   return insertSliceOp.getOperation();
 }
 

mlir/lib/Dialect/Linalg/Transforms/DataLayoutPropagation.cpp

 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tensor/Utils/Utils.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/IR/Dominance.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 namespace mlir {
 #define GEN_PASS_DEF_LINALGDATALAYOUTPROPAGATION
 #include "mlir/Dialect/Linalg/Passes.h.inc"
 } // namespace mlir
pushDownUnPackOpThroughElemGenericOp(RewriterBase &rewriter,
   Value unPackDest = producerUnPackOp.getDest();
   auto genericOutElementType = getElementTypeOrSelf(genericOp.getResult(0));
   if (producerUnPackOp.getDestType().getElementType() !=
       genericOutElementType) {
     SmallVector<OpFoldResult> unPackMixedSizes;
     if (auto unPackEmpty = unPackDest.getDefiningOp<tensor::EmptyOp>())
       unPackMixedSizes = unPackEmpty.getMixedSizes();
     else
-      unPackMixedSizes = tensor::getMixedSizes(rewriter, loc, unPackDest);
+      unPackMixedSizes = reifyShapeDims(rewriter, loc, unPackDest);
 
     unPackDest = rewriter.create<tensor::EmptyOp>(loc, unPackMixedSizes,
                                                   genericOutElementType);
   }
 
   // Insert an unPackOp right after the packed generic.
   Value unPackOpRes =
       rewriter

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tensor/Transforms/Transforms.h"
 #include "mlir/Dialect/Tensor/Utils/Utils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMS
LogicalResult matchAndRewrite(GenericOp genericOp,
 
     Location loc = genericOp.getLoc();
     SmallVector<Value> newOutputOperands = outputOperands;
     for (OpOperand *op : candidates) {
       OpBuilder::InsertionGuard guard(rewriter);
       rewriter.setInsertionPointAfterValue(op->get());
       auto elemType = op->get().getType().cast<ShapedType>().getElementType();
       auto empty = rewriter.create<tensor::EmptyOp>(
-          loc, tensor::createDimValues(rewriter, loc, op->get()), elemType);
+          loc, reifyShapeDims(rewriter, loc, op->get()), elemType);
 
       auto [start, end] = genericOp.getDpsInitsPositionRange();
       newOutputOperands[op->getOperandNumber() - start] = empty.getResult();
     }
 
     auto newOp = rewriter.create<GenericOp>(
         loc, genericOp.getResultTypes(), newInputOperands, newOutputOperands,
         newIndexingMaps, genericOp.getIteratorTypesArray(),
Value expandValue(Value result, Value origOutput,
                     ArrayRef<ReassociationIndices> reassociation, Location loc,
                     PatternRewriter &rewriter) const {
     // There are no results for memref outputs.
     auto origResultType = origOutput.getType().cast<RankedTensorType>();
     if (rankReductionStrategy == RankReductionStrategy::ExtractInsertSlice) {
       unsigned rank = origResultType.getRank();
       SmallVector<OpFoldResult> offsets(rank, rewriter.getIndexAttr(0));
       SmallVector<OpFoldResult> sizes =
-          tensor::getMixedSizes(rewriter, loc, origOutput);
+          reifyShapeDims(rewriter, loc, origOutput);
       SmallVector<OpFoldResult> strides(rank, rewriter.getIndexAttr(1));
       return rewriter.createOrFold<tensor::InsertSliceOp>(
           loc, result, origOutput, offsets, sizes, strides);
     }
 
     assert(rankReductionStrategy ==
                RankReductionStrategy::ReassociativeReshape &&
            "unknown rank reduction strategy");

mlir/lib/Dialect/Linalg/Transforms/ElementwiseToLinalg.cpp

 //===- ElementwiseToLinalg.cpp - conversion of elementwise to linalg ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Passes.h"
 
 #include "mlir/Dialect/Arith/Utils/Utils.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTELEMENTWISETOLINALG
 #include "mlir/Dialect/Linalg/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
for (Type t : rankedTensorTypes) {
     }
     if (found)
       continue;
 
     // Extract static / dynamic shape mix from the first operand.
     Value firstOperand = operands.front();
     auto rankedTensorType = t.cast<RankedTensorType>();
     auto staticShape = llvm::to_vector<4>(rankedTensorType.getShape());
-    auto dynamicShape = linalg::getDynOperands(loc, firstOperand, b);
+    auto dynamicShape = reifyDynamicShapeDims(b, loc, firstOperand);
 
     res.push_back(b.create<tensor::EmptyOp>(
         loc, staticShape, rankedTensorType.getElementType(), dynamicShape));
   }
   return res;
 }
 
 namespace {

mlir/lib/Dialect/Linalg/Transforms/FusePadOpWithLinalgProducer.cpp

 // chain into a tensor.extract_slice -> linalg.generic -> tensor.insert_slice
 // op chain.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 
 /// A sequence of operations
 ///
auto fillTensor =
         rewriter.create<linalg::FillOp>(loc, padValue, emptyTensor.getResult());
 
     // Construct a slice of the fill result that is to be replaced with the
     // result of the generic op. The low pad values are the offsets, the size of
     // the source is the size of the slice.
     // TODO: This insert/extract could be potentially made a utility method.
     unsigned resultNumber = source.cast<OpResult>().getResultNumber();
     SmallVector<OpFoldResult> offsets = padOp.getMixedLowPad();
-    SmallVector<OpFoldResult> sizes;
-    sizes.reserve(offsets.size());
-    for (const auto &shape : llvm::enumerate(
-             source.getType().cast<RankedTensorType>().getShape())) {
-      if (ShapedType::isDynamic(shape.value())) {
-        sizes.push_back(
-            rewriter.create<tensor::DimOp>(loc, source, shape.index())
-                .getResult());
-      } else {
-        sizes.push_back(rewriter.getIndexAttr(shape.value()));
-      }
-    }
+    SmallVector<OpFoldResult> sizes = reifyShapeDims(rewriter, loc, source);
     SmallVector<OpFoldResult> strides(offsets.size(), rewriter.getIndexAttr(1));
     auto slice = rewriter.create<tensor::ExtractSliceOp>(
         loc, fillTensor.getResult(0), offsets, sizes, strides);
 
     // Clone the generic op.
     auto clonedOp =
         cast<linalg::GenericOp>(rewriter.clone(*linalgOp.getOperation()));
     clonedOp.setDpsInitOperand(resultNumber, slice.getResult());

mlir/lib/Dialect/Linalg/Transforms/SplitReduction.cpp

 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tensor/Utils/Utils.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 FailureOr<SplitReductionResult> mlir::linalg::splitReduction(
     PatternRewriter &b, LinalgOp op,
     const ControlSplitReductionFn &controlSplitReductionFn, bool useAlloc) {
   OpBuilder::InsertionGuard guard(b);
FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   SmallVector<Operation *> emptyOrAllocTensorOps;
   SmallVector<linalg::FillOp> fillOps;
   fillOps.reserve(op.getNumDpsInits());
   for (auto it : llvm::zip(op.getDpsInitOperands(), neutralElements)) {
     Value rankedTensor = std::get<0>(it)->get();
     auto t = rankedTensor.getType().cast<RankedTensorType>();
     RankedTensorType newT = RankedTensorType::Builder(t).insertDim(
         reductionDimSize / splitFactor, insertSplitDimension);
-    SmallVector<Value> dims =
-        tensor::createDynamicDimValues(b, loc, rankedTensor);
+    SmallVector<Value> dims = reifyDynamicShapeDims(b, loc, rankedTensor);
     Value emptyOrAllocTensor;
     if (useAlloc) {
       emptyOrAllocTensor =
           b.create<bufferization::AllocTensorOp>(loc, newT, dims);
     } else {
       emptyOrAllocTensor = b.create<tensor::EmptyOp>(loc, newT.getShape(),
                                                      t.getElementType(), dims);
     }

mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp

 #include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"
 #include "mlir/Dialect/Tensor/Utils/Utils.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <type_traits>
GeneralizePadOpPattern::matchAndRewrite(tensor::PadOp padOp,
   // Try optimize the copy of source.
   if (optimizeCopyFn && optimizeCopyFn(rewriter, padOp, fill).succeeded())
     return success();
 
   // tensor::PadOps cannot be optimized. Generate a InsertSliceOp instead
   // for copying the PadOp source.
   auto sourceType = padOp.getSourceType();
   // Compute size of source of tensor::PadOp.
-  SmallVector<OpFoldResult> srcSizes;
-  for (unsigned dim = 0; dim < sourceType.getRank(); ++dim) {
-    if (sourceType.isDynamicDim(dim)) {
-      srcSizes.push_back(rewriter.createOrFold<tensor::DimOp>(
-          padOp.getLoc(), padOp.getSource(), dim));
-    } else {
-      srcSizes.push_back(rewriter.getIndexAttr(sourceType.getDimSize(dim)));
-    }
-  }
+  SmallVector<OpFoldResult> srcSizes =
+      reifyShapeDims(rewriter, padOp.getLoc(), padOp.getSource());
   // Strides of InsertSliceOp are all 1.
   SmallVector<OpFoldResult> strides(sourceType.getRank(),
                                     rewriter.getIndexAttr(1));
   rewriter.replaceOpWithNewOp<tensor::InsertSliceOp>(
       padOp, padOp.getSource(), fill, padOp.getMixedLowPad(), srcSizes,
       strides);
 
   return success();
LogicalResult GeneralizeOuterUnitDimsUnPackOpPattern::matchAndRewrite(
   auto transposedOp =
       rewriter.create<linalg::TransposeOp>(loc, innerTile, empty, perm);
 
   // 3. Handle in-complete tiles if needed. It truncates trailing data from the
   // transposed tile.
   int numLoops = transpShape.size();
   SmallVector<OpFoldResult> tileStrides(numLoops, oneIdxAttr);
   SmallVector<OpFoldResult> tileOffsets(numLoops, zeroIdxAttr);
-  SmallVector<OpFoldResult> tileSizes;
-  for (int dim : innerDimsPos)
-    tileSizes.push_back(getAsOpFoldResult(
-        rewriter.createOrFold<tensor::DimOp>(loc, unpackOp.getDest(), dim)));
+  SmallVector<OpFoldResult> tileSizes =
+      reifyShapeDims(rewriter, loc, unpackOp.getDest());
 
   applyPermutationToVector<OpFoldResult>(tileSizes, perm);
   auto partialTile = rewriter.create<tensor::ExtractSliceOp>(
       loc, transposedOp.getResult()[0], tileOffsets, tileSizes, tileStrides);
 
   // 4. Insert the result to the destination tensor.
   SmallVector<OpFoldResult> writeSizes;
   SmallVector<OpFoldResult> writeStrides(destRank, oneIdxAttr);

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include <type_traits>
 #include <optional>
+#include <type_traits>
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 #define DEBUG_TYPE "linalg-vectorization"
 
 #define DBGS() (llvm::dbgs() << '[' << DEBUG_TYPE << "] ")
 #define LDBG(X) LLVM_DEBUG(DBGS() << X << "\n")
for (int vecDim = 0, end = canonicalVecShape.size(); vecDim < end; ++vecDim) {
     // Find an operand defined on this dimension of the iteration space to
     // extract the runtime dimension size.
     Value operand;
     unsigned operandDimPos;
     if (failed(linalgOp.mapIterationSpaceDimToOperandDim(vecDim, operand,
                                                          operandDimPos)))
       return failure();
 
-    Value dynamicDim = linalgOp.hasTensorSemantics()
-                           ? (Value)rewriter.create<tensor::DimOp>(
-                                 linalgOp.getLoc(), operand, operandDimPos)
-                           : (Value)rewriter.create<memref::DimOp>(
-                                 linalgOp.getLoc(), operand, operandDimPos);
+    Value dynamicDim = getValueOrCreateConstantIndexOp(
+        rewriter, linalgOp.getLoc(),
+        reifyShapeDim(rewriter, linalgOp.getLoc(), operand, operandDimPos));
     iterSpaceDynamicSizes.push_back(dynamicDim);
   }
 
   return success();
 }
 
 /// Initializes the vectorization state, including the computation of the
 /// canonical vector shape for vectorization.

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

 bool isParallelIterator(utils::IteratorType iteratorType) {
   return iteratorType == utils::IteratorType::parallel;
 }
 
 bool isReductionIterator(utils::IteratorType iteratorType) {
   return iteratorType == utils::IteratorType::reduction;
 }
 
-/// Given an operation, retrieves the value of each dynamic dimension through
-/// constructing the necessary DimOp operators.
-SmallVector<Value, 4> getDynOperands(Location loc, Value val, OpBuilder &b) {
-  SmallVector<Value, 4> dynOperands;
-  auto shapedType = val.getType().cast<ShapedType>();
-  for (const auto &dim : llvm::enumerate(shapedType.getShape())) {
-    if (dim.value() == ShapedType::kDynamic)
-      dynOperands.push_back(getValueOrCreateConstantIndexOp(
-          b, loc, reifyShapeDim(b, loc, val, dim.index())));
-  }
-  return dynOperands;
-}
-
 void getUpperBoundForIndex(Value value, AffineMap &boundMap,
                            SmallVectorImpl<Value> &boundOperands,
                            bool constantRequired) {
   // Initialize `boundMap` and `boundOperands` to the identity returning
   // `value`. This combination is the default result of the method if no
   // simplification is possible.
   assert(value.getType().isIndex() && "expect value to have index type");
   boundMap = AffineMap::getMultiDimIdentityMap(1, value.getContext());

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 using namespace mlir;
 using namespace mlir::memref;
 

 Type mlir::memref::getTensorTypeFromMemRefType(Type type) {
   if (auto memref = type.dyn_cast<MemRefType>())
     return RankedTensorType::get(memref.getShape(), memref.getElementType());
   if (auto memref = type.dyn_cast<UnrankedMemRefType>())
     return UnrankedTensorType::get(memref.getElementType());
   return NoneType::get(type.getContext());
 }
 
-SmallVector<OpFoldResult> memref::getMixedSizes(OpBuilder &builder,
-                                                Location loc, Value value) {
-  auto memrefType = value.getType().cast<MemRefType>();
-  SmallVector<OpFoldResult> result;
-  for (int64_t i = 0; i < memrefType.getRank(); ++i) {
-    if (memrefType.isDynamicDim(i)) {
-      Value size = builder.create<memref::DimOp>(loc, value, i);
-      result.push_back(size);
-    } else {
-      result.push_back(builder.getIndexAttr(memrefType.getDimSize(i)));
-    }
-  }
-  return result;
-}
-
 //===----------------------------------------------------------------------===//
 // Utility functions for propagating static information
 //===----------------------------------------------------------------------===//
 
 /// Helper function that infers the constant values from a list of \p values,
 /// a \p memRefTy, and another helper function \p getAttributes.
 /// The inferred constant values replace the related `OpFoldResult` in
 /// \p values.
return getCanonicalSubViewResultType(currentResultType, sourceType,
                                        mixedStrides);
 }
 
 Value mlir::memref::createCanonicalRankReducingSubViewOp(
     OpBuilder &b, Location loc, Value memref, ArrayRef<int64_t> targetShape) {
   auto memrefType = memref.getType().cast<MemRefType>();
   unsigned rank = memrefType.getRank();
   SmallVector<OpFoldResult> offsets(rank, b.getIndexAttr(0));
-  SmallVector<OpFoldResult> sizes = getMixedSizes(b, loc, memref);
+  SmallVector<OpFoldResult> sizes = reifyShapeDims(b, loc, memref);
   SmallVector<OpFoldResult> strides(rank, b.getIndexAttr(1));
   auto targetType = SubViewOp::inferRankReducedResultType(
                         targetShape, memrefType, offsets, sizes, strides)
                         .cast<MemRefType>();
   return b.createOrFold<memref::SubViewOp>(loc, targetType, memref, offsets,
                                            sizes, strides);
 }
 

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

static bool isZeroYield(GenericOp op) {
   }
   return isZeroValue(yieldOp.getOperand(0));
 }
 
 /// Populates given sizes array from type (for static sizes) and from
 /// the tensor (for dynamic sizes).
 static void sizesForTensor(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
                            Location loc, ShapedType stp, Value tensor) {
-  for (const auto &d : enumerate(stp.getShape())) {
-    Value dim;
-    if (d.value() == ShapedType::kDynamic)
-      dim = builder.create<tensor::DimOp>(loc, tensor, d.index());
-    else
-      dim = constantIndex(builder, loc, d.value());
-    sizes.push_back(dim);
-  }
+  for (int64_t dim = 0; dim < stp.getRank(); ++dim)
+    sizes.push_back(getValueOrCreateConstantIndexOp(
+        builder, loc, reifyShapeDim(builder, loc, tensor, dim)));
 }
 
 // TODO: The dim level property of the COO type relies on input tensors, the
 // shape relies on the output tensor
 static RankedTensorType
 getUnorderedCOOFromTypeWithOrdering(RankedTensorType src, AffineMap ordering) {
   return getCOOFromTypeWithOrdering(src, ordering, false);
 }

mlir/lib/Dialect/Tensor/IR/CMakeLists.txt

add_mlir_dialect_library(MLIRTensorTilingInterfaceImpl
   MLIRAffineDialect
   MLIRAffineUtils
   MLIRArithUtils
   MLIRDialectUtils
   MLIRIR
   MLIRLinalgDialect
   MLIRLinalgUtils
   MLIRSCFDialect
+  MLIRShapedTypeInterfaces
   MLIRSupport
   MLIRTensorDialect
   MLIRTensorUtils
   MLIRTilingInterface
   )

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributeInterfaces.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Interfaces/DestinationStyleOpInterface.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <algorithm>
 #include <optional>
 
 using namespace mlir;
 using namespace mlir::tensor;
 
 /// Materialize a single constant operation from a given attribute value with
 /// the desired resultant type.
 Operation *TensorDialect::materializeConstant(OpBuilder &builder,
                                               Attribute value, Type type,
                                               Location loc) {
   if (arith::ConstantOp::isBuildableWith(value, type))
     return builder.create<arith::ConstantOp>(loc, value, type);
   if (complex::ConstantOp::isBuildableWith(value, type))
     return builder.create<complex::ConstantOp>(loc, type,
                                                value.cast<ArrayAttr>());
   return nullptr;
 }
 
-SmallVector<OpFoldResult> tensor::getMixedSizes(OpBuilder &builder,
-                                                Location loc, Value value) {
-  auto tensorType = value.getType().cast<RankedTensorType>();
-  SmallVector<OpFoldResult> result;
-  for (int64_t i = 0; i < tensorType.getRank(); ++i) {
-    if (tensorType.isDynamicDim(i)) {
-      Value size = builder.create<tensor::DimOp>(loc, value, i);
-      result.push_back(size);
-    } else {
-      result.push_back(builder.getIndexAttr(tensorType.getDimSize(i)));
-    }
-  }
-  return result;
-}
-
 FailureOr<Value> tensor::getOrCreateDestination(OpBuilder &b, Location loc,
                                                 OpResult opResult) {
   auto tensorType = opResult.getType().dyn_cast<TensorType>();
   assert(tensorType && "expected tensor type");
 
   // If the op has a destination, it implements DestinationStyleOpInterface and
   // we can query the destination operand from that interface.
   auto destOp = opResult.getDefiningOp<DestinationStyleOpInterface>();
OpFoldResult ExtractSliceOp::fold(FoldAdaptor adaptor) {
   return OpFoldResult();
 }
 
 Value mlir::tensor::createCanonicalRankReducingExtractSliceOp(
     OpBuilder &b, Location loc, Value tensor, RankedTensorType targetType) {
   auto rankedTensorType = tensor.getType().cast<RankedTensorType>();
   unsigned rank = rankedTensorType.getRank();
   SmallVector<OpFoldResult> offsets(rank, b.getIndexAttr(0));
-  SmallVector<OpFoldResult> sizes = getMixedSizes(b, loc, tensor);
+  SmallVector<OpFoldResult> sizes = reifyShapeDims(b, loc, tensor);
   SmallVector<OpFoldResult> strides(rank, b.getIndexAttr(1));
   return b.createOrFold<tensor::ExtractSliceOp>(loc, targetType, tensor,
                                                 offsets, sizes, strides);
 }
 
 //===----------------------------------------------------------------------===//
 // InsertSliceOp
 //===----------------------------------------------------------------------===//
if (succeeded(foldInsertAfterInsertSlice(*this)))
     return getResult();
   if (auto result = foldInsertAfterExtractSlice(*this))
     return result;
   return OpFoldResult();
 }
 
 LogicalResult InsertSliceOp::reifyResultShapes(
     OpBuilder &builder, ReifiedRankedShapedTypeDims &reifiedReturnShapes) {
-  reifiedReturnShapes.resize(1, SmallVector<OpFoldResult>(getType().getRank()));
-  for (auto dim : llvm::seq<int64_t>(0, getType().getRank())) {
-    if (getType().isDynamicDim(dim)) {
-      reifiedReturnShapes[0][dim] =
-          builder.createOrFold<tensor::DimOp>(getLoc(), getDest(), dim);
-    } else {
-      reifiedReturnShapes[0][dim] =
-          builder.getIndexAttr(getType().getDimSize(dim));
-    }
-  }
+  reifiedReturnShapes.push_back(getMixedSizes());
   return success();
 }
 
 namespace {
 /// Pattern to rewrite a insert_slice op with constant arguments.
 ///
 /// This pattern works with both InsertSliceOp and ParallelInsertSliceOp.
 template <typename InsertOpTy>

 
 Value mlir::tensor::createCanonicalRankReducingInsertSliceOp(OpBuilder &b,
                                                              Location loc,
                                                              Value tensor,
                                                              Value dest) {
   auto rankedTensorType = dest.getType().cast<RankedTensorType>();
   unsigned rank = rankedTensorType.getRank();
   SmallVector<OpFoldResult> offsets(rank, b.getIndexAttr(0));
-  SmallVector<OpFoldResult> sizes = getMixedSizes(b, loc, dest);
+  SmallVector<OpFoldResult> sizes = reifyShapeDims(b, loc, dest);
   SmallVector<OpFoldResult> strides(rank, b.getIndexAttr(1));
   return b.createOrFold<tensor::InsertSliceOp>(loc, tensor, dest, offsets,
                                                sizes, strides);
 }
 
 //===----------------------------------------------------------------------===//
 // PadOp
 //===----------------------------------------------------------------------===//

 }
 
 template <typename OpTy>
 static LogicalResult
 reifyResultShapesImpl(OpTy op, OpBuilder &builder,
                       ReifiedRankedShapedTypeDims &reifiedReturnShapes) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
-  int64_t destRank = op.getDestRank();
-  reifiedReturnShapes.resize(1, SmallVector<OpFoldResult>(destRank));
-  ShapedType resultType = op.getResult().getType().template cast<ShapedType>();
-  for (auto dim : llvm::seq<int64_t>(0, destRank)) {
-    if (resultType.isDynamicDim(dim)) {
-      reifiedReturnShapes[0][dim] =
-          builder.createOrFold<tensor::DimOp>(op.getLoc(), op.getDest(), dim);
-    } else {
-      reifiedReturnShapes[0][dim] =
-          builder.getIndexAttr(resultType.getDimSize(dim));
-    }
-  }
+  reifiedReturnShapes.push_back(
+      reifyShapeDims(builder, op.getLoc(), op.getDest()));
   return success();
 }
 
 template <typename OpTy>
 static DenseMap<int64_t, OpFoldResult> getDimAndTileMappingImpl(OpTy op) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
   DenseMap<int64_t, OpFoldResult> dimAndTileMapping;

mlir/lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp

 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Arith/Utils/Utils.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tensor/Utils/Utils.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 #include "mlir/Interfaces/TilingInterface.h"
 
 using namespace mlir;
 using namespace mlir::tensor;
 
 namespace {
 
 struct PadOpTiling : public TilingInterface::ExternalModel<PadOpTiling, PadOp> {
getTiledImplementation(Operation *op, OpBuilder &b,
     SmallVector<OpFoldResult> origOffsets(offsets.begin(), offsets.end());
     SmallVector<OpFoldResult> origSizes(sizes.begin(), sizes.end());
     applyPermToRange(origOffsets, origSizes,
                      invertPermutationVector(packOp.getOuterDimsPerm()));
 
     DenseMap<int64_t, OpFoldResult> dimAndTileMapping =
         packOp.getDimAndTileMapping();
     SmallVector<OpFoldResult> srcDimValues =
-        tensor::createDimValues(b, loc, packOp.getSource());
+        reifyShapeDims(b, loc, packOp.getSource());
     SmallVector<OpFoldResult> inputIndices, inputSizes;
     for (auto dim : llvm::seq<int64_t>(0, inputRank)) {
       using AV = AffineValueExpr;
       AffineBuilder ab(b, loc);
       AffineExpr dim0, dim1, sym;
       bindDims(b.getContext(), dim0, dim1);
       bindSymbols(b.getContext(), sym);
       if (dimAndTileMapping.count(dim)) {

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

 #include "mlir/Dialect/Bufferization/IR/DstBufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Operation.h"
+#include "mlir/Interfaces/ShapedTypeInterfaces.h"
 
 using namespace mlir;
 using namespace mlir::bufferization;
 using namespace mlir::tensor;
 
 namespace mlir {
 namespace tensor {
 namespace {
LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
     // tensor::PadOp is like tensor::GenerateOp: The only difference is that
     // only a part of the generated tensor is needed. For simplicity, we reuse
     // the same functionality here.
     Value filledBuffer = lowerGenerateLikeOpBody(
         rewriter, loc, *tensorAlloc, dynamicSizes, padOp.getBodyRegion());
 
     // Create tensor::InsertSliceOp.
     SmallVector<OpFoldResult> sliceSizes =
-        getMixedSizes(rewriter, loc, padOp.getSource());
+        reifyShapeDims(rewriter, loc, padOp.getSource());
     SmallVector<OpFoldResult> sliceStrides(srcType.getRank(),
                                            rewriter.getIndexAttr(1));
     rewriter.replaceOpWithNewOp<tensor::InsertSliceOp>(
         padOp, padOp.getSource(), filledBuffer,
         /*offsets=*/padOp.getMixedLowPad(), sliceSizes, sliceStrides);
 
     return success();
   }

mlir/lib/Dialect/Tensor/Utils/Utils.cpp

for (const auto &en : enumerate(type.getShape())) {
     bindDims(b.getContext(), d0);
     auto dimOp = b.createOrFold<tensor::DimOp>(loc, source, en.index());
     high[en.index()] =
         makeComposedAffineApply(b, loc, en.value() - d0, {dimOp}).getResult();
   }
   return b.create<PadOp>(loc, type, source, low, high, pad, nofold);
 }
 
-SmallVector<Value> mlir::tensor::createDynamicDimValues(OpBuilder &b,
-                                                        Location loc,
-                                                        Value rankedTensor) {
-  auto tensorTy = rankedTensor.getType().cast<RankedTensorType>();
-  SmallVector<Value> dynamicDims;
-  for (const auto &en : llvm::enumerate(tensorTy.getShape())) {
-    if (en.value() == ShapedType::kDynamic)
-      dynamicDims.push_back(
-          b.create<tensor::DimOp>(loc, rankedTensor, en.index()));
-  }
-  return dynamicDims;
-}
-
-SmallVector<OpFoldResult>
-mlir::tensor::createDimValues(OpBuilder &b, Location loc, Value rankedTensor) {
-  auto tensorTy = rankedTensor.getType().cast<RankedTensorType>();
-  SmallVector<OpFoldResult> dims;
-  for (const auto &en : llvm::enumerate(tensorTy.getShape())) {
-    if (ShapedType::isDynamic(en.value())) {
-      dims.push_back(
-          b.createOrFold<tensor::DimOp>(loc, rankedTensor, en.index()));
-    } else {
-      dims.push_back(b.getIndexAttr(en.value()));
-    }
-  }
-  return dims;
-}
-
 FailureOr<RankedTensorType>
 mlir::tensor::computeTransposedType(RankedTensorType rankedTensorType,
                                     ArrayRef<int64_t> transposeVector) {
   if (transposeVector.empty())
     return rankedTensorType;
   if (!isPermutationVector(transposeVector) ||
       transposeVector.size() != static_cast<size_t>(rankedTensorType.getRank()))
     return failure();

mlir/lib/Interfaces/ShapedTypeInterfaces.cpp

auto shapedTypeInterface =
       shapedValue.getType().cast<ReifyShapeDimTypeInterface>();
   return shapedTypeInterface.reifyShapeDim(builder, loc, shapedValue, dim);
 }
 
 OpFoldResult mlir::reifyShapeDim(OpBuilder &builder, Location loc,
                                  Value shapedValue, int64_t dim) {
   return reifyShapeDim(builder, loc, shapedValue, builder.getIndexAttr(dim));
 }
+
+SmallVector<OpFoldResult> mlir::reifyShapeDims(OpBuilder &builder, Location loc,
+                                               Value shapedValue) {
+  auto shapedType = shapedValue.getType().cast<ShapedType>();
+  assert(shapedType.hasRank() && "expected ranked shaped value");
+  return llvm::to_vector(llvm::map_range(
+      llvm::seq<int64_t>(0, shapedType.getRank()), [&](int64_t dim) {
+        return reifyShapeDim(builder, loc, shapedValue, dim);
+      }));
+}
+
+SmallVector<Value> mlir::reifyDynamicShapeDims(OpBuilder &builder, Location loc,
+                                               Value shapedValue) {
+  SmallVector<Value> result;
+  auto shapedType = shapedValue.getType().cast<ShapedType>();
+  assert(shapedType.hasRank() && "expected ranked shaped value");
+  for (const auto &dim : llvm::enumerate(shapedType.getShape()))
+    if (dim.value() == ShapedType::kDynamic)
+      result.push_back(
+          reifyShapeDim(builder, loc, shapedValue, dim.index()).get<Value>());
+  return result;
+}

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

deps = [
         ":AffineDialect",
         ":AffineUtils",
         ":ArithUtils",
         ":DialectUtils",
         ":IR",
         ":LinalgDialect",
         ":LinalgUtils",
         ":SCFDialect",
+        ":ShapedTypeInterfaces",
         ":TensorDialect",
         ":TensorUtils",
         ":TilingInterface",
         "//llvm:Support",
     ],
 )
 
 cc_library(
deps = [
         ":IR",
         ":LinalgDialect",
         ":LinalgTransformOpsIncGen",
         ":LinalgTransforms",
         ":LinalgUtils",
         ":PDLDialect",
         ":Parser",
         ":SCFTransforms",
+        ":ShapedTypeInterfaces",
         ":SideEffectInterfaces",
         ":Support",
         ":TensorDialect",
         ":TensorUtils",
         ":TilingInterface",
         ":TransformDialect",
         ":TransformDialectUtils",
         ":TransformUtils",
deps = [
         ":BufferizationOpsIncGen",
         ":ControlFlowInterfaces",
         ":CopyOpInterface",
         ":DestinationStyleOpInterface",
         ":FuncDialect",
         ":IR",
         ":InferTypeOpInterface",
         ":MemRefDialect",
+        ":ShapedTypeInterfaces",
         ":SparseTensorDialect",
         ":Support",
         ":TensorDialect",
         "//llvm:Support",
     ],
 )
 
 gentbl_cc_library(