Reduce input arguments for `getPackingInfoFromConsumer` (NFC)

[chelini]

Summary

Pass to getPackingInfoFromConsumer the tensor.pack op instead of all
the arguments derived from it. Additionally, remove the padding from the
struct, as we currently don't handle propagation when tensor.pack
requires padding. We will add back the field when we will need it.

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

struct PackInfo {
   SmallVector<int64_t> tiledDimsPos;
   // The sizes of tiling data dimensions on iteration domain.
   llvm::DenseMap<int64_t, OpFoldResult> domainDimAndTileMapping;
   // The mapping from a dimension of iteration domain to the corresponding inner
   // tiling dimension on iteration domain.
   llvm::DenseMap<int64_t, int64_t> tileToPointMapping;
   // The permutation of outer dims (on domain).
   SmallVector<int64_t> outerDimsOnDomainPerm;
-  std::optional<Value> paddingValue;
 };
 
-static PackInfo getPackingInfoFromConsumer(
-    AffineMap indexingMap, ArrayRef<OpFoldResult> innerTileSizes,
-    ArrayRef<int64_t> innerDimsPos, ArrayRef<int64_t> outerDimsPerm,
-    std::optional<Value> paddingValue = std::nullopt) {
+static PackInfo getPackingInfoFromConsumer(AffineMap indexingMap,
+                                           tensor::PackOp packOp) {
   LLVM_DEBUG(
       { llvm::dbgs() << "--- Construct PackInfo From A Consumer ---\n"; });
   PackInfo packInfo;
-  packInfo.paddingValue = paddingValue;
   int64_t origNumDims = indexingMap.getNumDims();
   SmallVector<AffineExpr> exprs(indexingMap.getResults());
+  ArrayRef<int64_t> innerDimsPos = packOp.getInnerDimsPos();
   for (auto [index, innerDimPos, tileSize] :
        llvm::zip_equal(llvm::seq<unsigned>(0, innerDimsPos.size()),
-                       innerDimsPos, innerTileSizes)) {
+                       innerDimsPos, packOp.getMixedTiles())) {
     int64_t domainDimPos =
         exprs[innerDimPos].cast<AffineDimExpr>().getPosition();
     packInfo.tiledDimsPos.push_back(domainDimPos);
     packInfo.domainDimAndTileMapping[domainDimPos] = tileSize;
     packInfo.tileToPointMapping[domainDimPos] = origNumDims + index;
     LLVM_DEBUG({
       llvm::dbgs() << "map innerDimPos=" << innerDimPos
                    << " to iteration dimension (d" << domainDimPos << ", d"
                    << packInfo.tileToPointMapping[domainDimPos]
                    << "), which has size=("
                    << packInfo.domainDimAndTileMapping[domainDimPos] << ")\n";
     });
   }
 
-  for (auto dim : outerDimsPerm)
+  for (auto dim : packOp.getOuterDimsPerm())
     packInfo.outerDimsOnDomainPerm.push_back(indexingMap.getDimPosition(dim));
   if (!packInfo.outerDimsOnDomainPerm.empty()) {
     LLVM_DEBUG({
       llvm::dbgs() << "map outer dimsDimsPerm to ";
       for (auto dim : packInfo.outerDimsOnDomainPerm)
         llvm::dbgs() << dim << " ";
       llvm::dbgs() << "\n";
     });
getOrCreatePackedViewOfOperand(OpBuilder &b, Location loc, PackInfo packInfo,
   // The operand does not have dimensions that relates to pack op.
   if (innerDimsPos.empty())
     return std::make_tuple(opOperand->get(), indexingMap);
 
   auto empty = tensor::PackOp::createDestinationTensor(
       b, loc, opOperand->get(), innerTileSizes, innerDimsPos, outerDimsPerm);
   auto packedOperand = b.create<tensor::PackOp>(
       loc, opOperand->get(), empty, innerDimsPos, innerTileSizes,
-      packInfo.paddingValue, outerDimsPerm);
+      /*padding=*/std::nullopt, outerDimsPerm);
   return std::make_tuple(packedOperand, indexingMap);
 }
 
 /// Bubbles up tensor.pack op through elementwise generic op. This
 /// swap pack(generic) to generic(pack). The new generic op works on packed
 /// domain; pack ops are created for input and output operands. E.g.,
 ///
 ///     #map0 = affine_map<(d0, d1) -> (d0, d1)>
bubbleUpPackOpThroughElemGenericOp(RewriterBase &rewriter,
   // undefined behavior if we unconditionally propagate pack op through all
   // the ops. E.g., if the padding value is zero and there are division ops in
   // a generic op. Some values of padding area could be NaN (0/0).
   if (packOp.getPaddingValue())
     return failure();
 
   OpOperand *opOperand = genericOp.getDpsInitOperand(0);
   auto packInfo = getPackingInfoFromConsumer(
-      genericOp.getMatchingIndexingMap(opOperand), packOp.getMixedTiles(),
-      packOp.getInnerDimsPos(), packOp.getOuterDimsPerm(),
-      packOp.getPaddingValue());
+      genericOp.getMatchingIndexingMap(opOperand), packOp);
 
   Location loc = packOp.getLoc();
   SmallVector<Value> inputOperands;
   SmallVector<AffineMap> indexingMaps;
   for (OpOperand *inputOperand : genericOp.getDpsInputOperands()) {
     auto [packedOperand, packedIndexingMap] = getOrCreatePackedViewOfOperand(
         rewriter, loc, packInfo, genericOp, inputOperand);
     inputOperands.push_back(packedOperand);