[mlir][tosa] align the type of padding and pad_const with the spec

[tatwaichong]

Summary

padding and pad_const are operands in the current implementation,
but in TOSA spec they are attributes.

Instead of being value agnostic operand type, switch these arguments
to static attribute type.

Change-Id: I529c8a1a0848627ead7950c7028a964977bf1497

[tatwaichong]

update the patch title

Updating D143312: Summary:

padding and pad_const are operands in the current implementation,
but in TOSA spec they are attributes.

[jpienaar]

I'm confused, I thought these were going the other way. E.g., there is a mismatch between what the spec calls an attribute and MLIR does, previously we had mostly err'd on treating them the same. But as the spec really requires this before execute/offload rather than representationaly , I thought the conclusion was that these should be operands and one had like a verify for export/runtime pass to flag that the operands are actually constants at that point.

[tatwaichong]

Sorry for confusing you. I've not noticed there is a mismatch of attribute meaning between TOSA and MLIR. Could you explain a bit about the difference or why those arguments are better to be MLIR operands rather than MLIR attributes? I thought both attribute types are used to specify constant data on operations.
Alternative way without the pad definition changing, we're trying to add a section in a pass in MLIR to verify if the pad operands are constant in compile time. Any suggestions are welcome.

[rsuderman]

In D143312#4113508, @tatwaichong wrote:

Sorry for confusing you. I've not noticed there is a mismatch of attribute meaning between TOSA and MLIR. Could you explain a bit about the difference or why those arguments are better to be MLIR operands rather than MLIR attributes? I thought both attribute types are used to specify constant data on operations.
Alternative way without the pad definition changing, we're trying to add a section in a pass in MLIR to verify if the pad operands are constant in compile time. Any suggestions are welcome.

It would make more sense to use an m_Constant check for validating that values expected to be constants are constants rather than changing a Value to an Attribute. Overall we should be moving away from Attributes towards Value based execution to have a better chance of supporting dynamically shaped models.

[tatwaichong]

Thanks. Feedbacks from you guys are useful and constructive. Let me abandon this PR and go along the suggested way.

mlir/include/mlir/Dialect/Tosa/IR/CMakeLists.txt

 add_mlir_dialect(TosaOps tosa)
 add_mlir_doc(TosaOps TosaOps Dialects/ -gen-op-doc)
 add_mlir_interface(TosaInterfaces)
 
 set(LLVM_TARGET_DEFINITIONS TosaOps.td)
-mlir_tablegen(TosaAttributes.h.inc -gen-attrdef-decls)
-mlir_tablegen(TosaAttributes.cpp.inc -gen-attrdef-defs)
+mlir_tablegen(TosaAttributes.h.inc -gen-attrdef-decls -attrdefs-dialect=tosa)
+mlir_tablegen(TosaAttributes.cpp.inc -gen-attrdef-defs -attrdefs-dialect=tosa)
 add_public_tablegen_target(MLIRTosaAttributesIncGen)

mlir/include/mlir/Dialect/Tosa/IR/TosaOpBase.td

def Tosa_UnaryOpQuantInfoBuilder : OpBuilder<
   [{
     buildUnaryOpWithQuantInfo($_builder, $_state, outputType, input);
   }]>;
 
 // These builders are called on the TOSA pad operator that needs to create its
 // own OptionalAttr quantization_attr parameter to scale the padding values
 // correctly.
 def Tosa_PadOpQuantInfoBuilder : OpBuilder<
-  (ins "Type":$outputType, "Value":$input, "Value":$paddings),
+  (ins "Type":$outputType, "Value":$input, "DenseI32ArrayAttr":$padding),
   [{
     buildPadOpWithQuantInfo($_builder, $_state, outputType,
-                            input, paddings);
+                            input, padding);
   }]>;
 
 def Tosa_ExplicitValuePadOpQuantInfoBuilder : OpBuilder<
-  (ins "Type":$outputType, "Value":$input, "Value":$paddings,
-       "Value":$pad_value),
+  (ins "Type":$outputType, "Value":$input,
+       "DenseI32ArrayAttr":$padding,
+       "DenseIntOrFPElementsAttr":$pad_const),
   [{
     buildExplicitValuePadOpWithQuantInfo($_builder, $_state, outputType,
-                                         input, paddings, pad_value);
+                                         input, padding, pad_const);
   }]>;
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator.
 //===----------------------------------------------------------------------===//
 
 class Tosa_Op<string mnemonic, list<Trait> traits = []> :
     Op<Tosa_Dialect, mnemonic, !listconcat(traits, [TosaOpInterface])> {
 }
 
 #endif // TOSA_OP_BASE

mlir/include/mlir/Dialect/Tosa/IR/TosaOps.td

 // the TOSA specfication (https://developer.mlplatform.org/w/tosa/).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOSA_OPS
 #define TOSA_OPS
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/BuiltinAttributes.td"
 
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Dialect/Tosa/IR/TosaInterfaces.td"
 
 include "mlir/Dialect/Tosa/IR/TosaTypesBase.td"
 include "mlir/Dialect/Tosa/IR/TosaOpBase.td"
def Tosa_PadOp : Tosa_Op<"pad", [
   let summary = "Pads a tensor with value specified.";
 
   let description = [{
     Pads a tensor along borders of each dimension with pad_value.
   }];
 
   let arguments = (ins
     Tosa_RankedTensor:$input1,
-    Tosa_Int32Or64Tensor:$padding,
-    Optional<Tosa_ScalarTensor>:$pad_const,
+    DenseI32ArrayAttr:$padding,
+    OptionalAttr<Builtin_DenseIntOrFPElementsAttr>:$pad_const,
     OptionalAttr<Tosa_PadOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_RankedTensor:$output
   );
 
   let builders = [Tosa_PadOpQuantInfoBuilder,

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

 class PadConverter : public OpRewritePattern<tosa::PadOp> {
 public:
   using OpRewritePattern<tosa::PadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::PadOp padOp,
                                 PatternRewriter &rewriter) const final {
     auto loc = padOp.getLoc();
     auto input = padOp.getInput1();
-    auto padding = padOp.getPadding();
 
     ShapedType inputTy = input.getType().cast<ShapedType>();
     Type elementTy = inputTy.getElementType();
+
     int64_t rank = inputTy.getRank();
+    SmallVector<int32_t> padding_array(padOp.getPadding());
+    RankedTensorType padding_shape =
+        RankedTensorType::get({rank, 2}, rewriter.getI32Type());
+    DenseIntElementsAttr padding_attr =
+        DenseIntElementsAttr::get(padding_shape, padding_array);
+    Value padding = rewriter.createOrFold<arith::ConstantOp>(loc, padding_attr);
 
     // Setup the default constantAttr.
-
     Value padConstant;
-
     if (padOp.getPadConst()) {
-      padConstant = rewriter.createOrFold<tensor::ExtractOp>(
-          loc, padOp.getPadConst(), ValueRange({}));
+      Value pad_const = rewriter.createOrFold<arith::ConstantOp>(
+          loc, padOp.getPadConstAttr());
+      padConstant = rewriter.createOrFold<tensor::ExtractOp>(loc, pad_const,
+                                                             ValueRange({}));
     } else {
       Attribute constantAttr;
       if (elementTy.isa<FloatType>()) {
         constantAttr = rewriter.getFloatAttr(elementTy, 0.0);
       } else if (elementTy.isa<IntegerType>() && !padOp.getQuantizationInfo()) {
         constantAttr = rewriter.getIntegerAttr(elementTy, 0);
       } else if (elementTy.isa<IntegerType>() && padOp.getQuantizationInfo()) {
         int64_t value = padOp.getQuantizationInfo()->getInputZp();

mlir/lib/Dialect/Tosa/IR/TosaCanonicalizations.cpp

struct MaterializePadValue : public OpRewritePattern<tosa::PadOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::PadOp op,
                                 PatternRewriter &rewriter) const override {
     if (op.getPadConst())
       return failure();
 
     auto input = op.getInput1();
-    auto padding = op.getPadding();
-
     ShapedType inputTy = input.getType().cast<ShapedType>();
     Type elementTy = inputTy.getElementType();
+    Attribute constantAttr = rewriter.getZeroAttr(elementTy);
 
-    Attribute constantAttr;
-    if (elementTy.isa<FloatType>()) {
-      constantAttr = rewriter.getFloatAttr(elementTy, 0.0);
-    } else if (elementTy.isa<IntegerType>() && !op.getQuantizationInfo()) {
-      constantAttr = rewriter.getIntegerAttr(elementTy, 0);
-    } else if (elementTy.isa<IntegerType>() && op.getQuantizationInfo()) {
-      auto value = op.getQuantizationInfo()->getInputZp();
-      constantAttr = rewriter.getIntegerAttr(elementTy, value);
-    }
+    if (auto quantizationInfo = op.getQuantizationInfo()) {
+      int64_t iZp = quantizationInfo->getInputZp();
 
-    if (!constantAttr) {
+      if (!validIntegerRange(elementTy.cast<IntegerType>(), iZp))
         return rewriter.notifyMatchFailure(
-          op,
-          "tosa.pad to linalg lowering encountered an unknown element type");
+            op, "tosa.pad op quantization has zp outside of input range");
+
+      constantAttr = rewriter.getIntegerAttr(elementTy, iZp);
+    }
+
+    auto padTy = RankedTensorType::get({}, elementTy);
+    DenseIntOrFPElementsAttr constantVal;
+    if (elementTy.isa<IntegerType>()) {
+      constantVal = DenseIntElementsAttr::get(padTy, constantAttr);
+    } else {
+      constantVal = DenseFPElementsAttr::get(padTy, constantAttr);
     }
 
-    auto denseAttr = DenseElementsAttr::get(
-        RankedTensorType::get({}, elementTy), constantAttr);
-    auto constantVal = rewriter.create<tosa::ConstOp>(
-        op.getLoc(), denseAttr.getType(), denseAttr);
-
-    rewriter.replaceOpWithNewOp<tosa::PadOp>(
-        op, op.getType(), ValueRange{input, padding, constantVal},
-        op->getAttrs());
+    rewriter.replaceOpWithNewOp<tosa::PadOp>(op, op.getType(), input,
+                                             op.getPaddingAttr(), constantVal);
     return success();
   }
 };
 
 void PadOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.add<MaterializePadValue>(context);
 }
OpFoldResult ReshapeOp::fold(FoldAdaptor adaptor) {
   if (operand && outputTy.hasStaticShape() && operand.isSplat()) {
     return SplatElementsAttr::get(outputTy, operand.getSplatValue<Attribute>());
   }
 
   return {};
 }
 
 OpFoldResult PadOp::fold(FoldAdaptor adaptor) {
+  DenseI32ArrayAttr padding = adaptor.getPaddingAttr();
   // If the pad is all zeros we can fold this operation away.
-  if (adaptor.getPadding()) {
-    auto densePad = adaptor.getPadding().cast<DenseElementsAttr>();
-    if (densePad.isSplat() && densePad.getSplatValue<APInt>().isZero()) {
-      return getInput1();
+  for (int i = 0; i < padding.size(); i++) {
+    if (padding[i] != 0) {
+      return {};
     }
   }
-
-  return {};
+  return getInput1();
 }
 
 // Fold away cases where a tosa.resize operation returns a copy
 // of the input image.
 OpFoldResult ResizeOp::fold(FoldAdaptor adaptor) {
   ArrayRef<int64_t> offset = getOffset();
   ArrayRef<int64_t> border = getBorder();
   ArrayRef<int64_t> scale = getScale();

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

static void buildUnaryOpWithQuantInfo(OpBuilder &builder,
   result.types.push_back(outputType);
 }
 
 /// This builder is called on TOSA pad operator that needs to create its own
 /// OptionalAttr quantization_attr parameter to scale the padding values
 /// correctly. No pad_const is interpreted as zero-padding.
 static void buildPadOpWithQuantInfo(OpBuilder &builder, OperationState &result,
                                     Type outputType, Value input,
-                                    Value paddings) {
-  result.addOperands({input, paddings});
+                                    DenseI32ArrayAttr padding) {
+  result.addOperands({input});
+  result.addAttribute("padding", padding);
+
+  Type outputETy = outputType.cast<ShapedType>().getElementType();
+  Attribute zeroAttr = builder.getZeroAttr(outputETy);
+  DenseIntOrFPElementsAttr pad_const;
+  auto padTy = RankedTensorType::get({}, outputETy);
+
+  if (outputETy.isa<IntegerType>()) {
+    pad_const = DenseIntElementsAttr::get(padTy, zeroAttr);
+  } else {
+    pad_const = DenseFPElementsAttr::get(padTy, zeroAttr);
+  }
+  result.addAttribute("pad_const", pad_const);
+
   auto quantAttr = buildPadOpQuantizationAttr(builder, input);
   if (quantAttr)
     result.addAttribute("quantization_info", quantAttr);
   result.types.push_back(outputType);
 }
 
 /// This builder is called on TOSA pad operator when an explicit pad_const
 /// value is passed in. It also optionally constructs quantization_attr.
-static void buildExplicitValuePadOpWithQuantInfo(OpBuilder &builder,
-                                                 OperationState &result,
-                                                 Type outputType, Value input,
-                                                 Value paddings,
-                                                 Value padConst) {
-  result.addOperands({input, paddings, padConst});
+static void buildExplicitValuePadOpWithQuantInfo(
+    OpBuilder &builder, OperationState &result, Type outputType, Value input,
+    DenseI32ArrayAttr padding, DenseIntOrFPElementsAttr pad_const) {
+  result.addOperands({input});
+  result.addAttribute("padding", padding);
+  result.addAttribute("pad_const", pad_const);
   auto quantAttr = buildPadOpQuantizationAttr(builder, input);
   if (quantAttr)
     result.addAttribute("quantization_info", quantAttr);
   result.types.push_back(outputType);
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Return Type Inference.
LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
   return success();
 }
 
 LogicalResult tosa::PadOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
-  ShapeAdaptor paddingShape = operands.getShape(1);
+  PadOpAdaptor adaptor(operands, attributes);
   SmallVector<int64_t> outputShape;
-
-  // If both inputs have unknown shape, we cannot determine the shape of the
-  // output.
-  if (!inputShape.hasRank() && !paddingShape.hasRank()) {
-    inferredReturnShapes.push_back(ShapedTypeComponents());
-    return success();
-  }
+  DenseI32ArrayAttr padding = adaptor.getPaddingAttr();
 
   // If the input rank is unknown we can info the output rank using the padding
-  // shape's first dim.
+  // size.
   if (!inputShape.hasRank()) {
-    if (paddingShape.isDynamicDim(0)) {
-      inferredReturnShapes.push_back(ShapedTypeComponents());
-      return success();
-    }
-
-    outputShape.resize(paddingShape.getDimSize(0), ShapedType::kDynamic);
-    inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
-    return success();
-  }
-
-  DenseIntElementsAttr paddings;
-  // If the paddings value is not a constant, all dimensions must be dynamic.
-  if (!matchPattern(operands[1], m_Constant(&paddings))) {
-    outputShape.resize(inputShape.getRank(), ShapedType::kDynamic);
+    outputShape.resize(padding.size() / 2, ShapedType::kDynamic);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
-  SmallVector<int64_t> paddingValues;
-  for (auto val : paddings) {
-    paddingValues.push_back(val.getSExtValue());
-  }
-
   outputShape.reserve(inputShape.getRank());
   for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     if (inputShape.isDynamicDim(i)) {
       outputShape.push_back(ShapedType::kDynamic);
       continue;
     }
 
-    outputShape.push_back(inputShape.getDimSize(i) + paddingValues[i * 2] +
-                          paddingValues[i * 2 + 1]);
+    outputShape.push_back(inputShape.getDimSize(i) + padding[i * 2] +
+                          padding[i * 2 + 1]);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 static SmallVector<int64_t> convertToMlirShape(ArrayRef<int64_t> shape) {
   return to_vector(llvm::map_range(shape, [](int64_t dim) {

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeConv2D.cpp

if (!llvm::all_of(op.getStride(), [](int64_t v) { return v == 1; }))
       return failure();
 
     // Only works for a 1x1 kernel.
     ArrayRef<int64_t> weightShape = weightType.getShape();
     if (weightShape[1] != 1 || weightShape[2] != 1)
       return failure();
 
     llvm::ArrayRef<int64_t> padAttr = op.getPad();
-    llvm::SmallVector<int64_t> pad(8, 0);
+    llvm::SmallVector<int32_t> pad(8, 0);
     for (const auto &it : llvm::enumerate(padAttr))
-      pad[it.index() + 2] = it.value();
+      pad[it.index() + 2] = static_cast<int32_t>(it.value());
 
     if (llvm::any_of(pad, [](int64_t p) { return p != 0; })) {
       Type inputETy = inputType.getElementType();
       Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
       if (op.getQuantizationInfo()) {
         auto quantizationInfo = op.getQuantizationInfo();
         int64_t iZp = quantizationInfo->getInputZp();
 
         if (!validIntegerRange(inputETy.cast<IntegerType>(), iZp))
           return rewriter.notifyMatchFailure(
               op, "tosa.conv op quantization has zp outside of input range");
 
         zeroAttr = rewriter.getIntegerAttr(inputETy, iZp);
       }
 
       llvm::SmallVector<int64_t> newShape(inputType.getShape());
 
       for (int i = 0, s = newShape.size(); i < s; ++i) {
         if (newShape[i] != ShapedType::kDynamic) {
           newShape[i] += pad[i * 2] + pad[i * 2 + 1];
         }
       }
 
-      auto padSizeTy = RankedTensorType::get({4, 2}, rewriter.getI64Type());
-      auto padSize =
-          DenseIntElementsAttr::get(padSizeTy, ArrayRef<int64_t>(pad));
-      Value padSizeVal =
-          rewriter.create<tosa::ConstOp>(op->getLoc(), padSizeTy, padSize);
-
       auto padTy = RankedTensorType::get({}, inputETy);
-      auto padAttr = DenseElementsAttr::get(padTy, zeroAttr);
-      Value padVal =
-          rewriter.create<tosa::ConstOp>(op->getLoc(), padTy, padAttr);
+      DenseIntOrFPElementsAttr padVal;
+      if (inputETy.isa<IntegerType>()) {
+        padVal = DenseIntElementsAttr::get(padTy, zeroAttr);
+      } else {
+        padVal = DenseFPElementsAttr::get(padTy, zeroAttr);
+      }
+
+      DenseI32ArrayAttr padSizeVal = rewriter.getDenseI32ArrayAttr(pad);
       inputType = RankedTensorType::get(newShape, inputETy);
       input = rewriter.create<tosa::PadOp>(op->getLoc(), inputType, input,
                                            padSizeVal, padVal);
     }
 
     // Reshape input to [N,IH,IW,IC] -> [N * IH * IW, IC].
     ArrayRef<int64_t> inputShape = inputType.getShape();
     int64_t combined = ShapedType::kDynamic;

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeDepthwise.cpp

if (auto quantizationInfo = op.getQuantizationInfo()) {
                                             zpVal);
       };
 
       input = applyZp(input, iZp);
       weight = applyZp(weight, wZp);
     }
 
     ArrayRef<int64_t> padAttr = op.getPad();
-    llvm::SmallVector<int64_t> pad(10, 0);
+    llvm::SmallVector<int32_t> pad(10, 0);
     for (const auto &it : llvm::enumerate(padAttr))
-      pad[it.index() + 2] = it.value();
+      pad[it.index() + 2] = static_cast<int32_t>(it.value());
 
     if (llvm::any_of(pad, [](int64_t p) { return p != 0; })) {
       Type inputETy = inputType.getElementType();
       Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
 
       llvm::SmallVector<int64_t> newShape(inputType.getShape());
       for (int i = 0, s = pad.size(); i < s; ++i) {
         if (newShape[i / 2] != ShapedType::kDynamic) {
           newShape[i / 2] += pad[i];
         }
       }
 
-      auto padSizeTy = RankedTensorType::get({5, 2}, rewriter.getI64Type());
-      auto padSize =
-          DenseIntElementsAttr::get(padSizeTy, ArrayRef<int64_t>(pad));
-      Value padSizeVal =
-          rewriter.create<tosa::ConstOp>(op->getLoc(), padSizeTy, padSize);
-
       auto padTy = RankedTensorType::get({}, inputETy);
-      auto padAttr = DenseElementsAttr::get(padTy, zeroAttr);
-      Value padVal =
-          rewriter.create<tosa::ConstOp>(op->getLoc(), padTy, padAttr);
+      DenseIntOrFPElementsAttr padVal;
+      if (inputETy.isa<IntegerType>()) {
+        padVal = DenseIntElementsAttr::get(padTy, zeroAttr);
+      } else {
+        padVal = DenseFPElementsAttr::get(padTy, zeroAttr);
+      }
+
+      DenseI32ArrayAttr padSizeVal =
+          rewriter.getDenseI32ArrayAttr(ArrayRef<int32_t>(pad));
       inputType = RankedTensorType::get(newShape, inputETy);
       input = rewriter.create<tosa::PadOp>(op->getLoc(), inputType, input,
                                            padSizeVal, padVal);
     }
 
     // Perform an elementwise mul over the reshaped input and weight.
     llvm::SmallVector<int64_t, 2> mulShape{
         inputType.getDimSize(0), inputType.getDimSize(1),

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp

LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
     int64_t inputChannels = weightTy.getDimSize(3);
 
     // Pad the weight so that it is modulo of the striding.
     llvm::SmallVector<int32_t, 8> weightPadding = {0, 0, 0, 0, 0, 0, 0, 0};
     weightPadding[3] =
         weightHeight % stride[0] ? stride[0] - weightHeight % stride[0] : 0;
     weightPadding[5] =
         weightWidth % stride[1] ? stride[1] - weightWidth % stride[1] : 0;
-    DenseElementsAttr weightPaddingAttr = DenseIntElementsAttr::get(
-        RankedTensorType::get({4, 2}, rewriter.getI32Type()), weightPadding);
-    Value weightPaddingVal = createOpAndInfer<tosa::ConstOp>(
-        rewriter, loc, weightPaddingAttr.getType(), weightPaddingAttr);
+
+    Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
+    auto padTy = RankedTensorType::get({}, inputETy);
+    DenseI32ArrayAttr weightPaddingVal =
+        rewriter.getDenseI32ArrayAttr(ArrayRef<int32_t>(weightPadding));
+    DenseIntOrFPElementsAttr pad_const_attr;
 
     if (op.getQuantizationInfo().has_value()) {
       auto quantInfo = op.getQuantizationInfo().value();
+      pad_const_attr = DenseIntElementsAttr::get(padTy, zeroAttr);
+
       weight = createOpAndInfer<tosa::PadOp>(
           rewriter, loc, UnrankedTensorType::get(weightETy), weight,
-          weightPaddingVal, nullptr,
+          weightPaddingVal, pad_const_attr,
           rewriter.getAttr<PadOpQuantizationAttr>(quantInfo.getWeightZp()));
 
     } else {
-      weight = createOpAndInfer<tosa::PadOp>(rewriter, loc,
-                                             UnrankedTensorType::get(weightETy),
-                                             weight, weightPaddingVal);
+      pad_const_attr = DenseFPElementsAttr::get(padTy, zeroAttr);
+      weight = createOpAndInfer<tosa::PadOp>(
+          rewriter, loc, UnrankedTensorType::get(weightETy), weight,
+          weightPaddingVal, pad_const_attr);
     }
 
     weightTy = weight.getType().cast<ShapedType>();
     weightHeight = weightTy.getDimSize(1);
     weightWidth = weightTy.getDimSize(2);
 
     // Split out the width / height by the stride dimensions.
     llvm::SmallVector<int64_t, 6> weightReshapeDims0 = {
LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
 
     // We need to pad the input far enough that we can pull all values.
     llvm::SmallVector<int32_t, 8> inputPadding = {0, 0, 0, 0, 0, 0, 0, 0};
     inputPadding[2] += restridedWeightTy.getDimSize(1) - 1;
     inputPadding[3] += restridedWeightTy.getDimSize(1) - 1;
     inputPadding[4] += restridedWeightTy.getDimSize(2) - 1;
     inputPadding[5] += restridedWeightTy.getDimSize(2) - 1;
 
-    DenseElementsAttr inputPaddingAttr = DenseIntElementsAttr::get(
-        RankedTensorType::get({4, 2}, rewriter.getI32Type()), inputPadding);
-
-    Value inputPaddingVal = createOpAndInfer<tosa::ConstOp>(
-        rewriter, loc, inputPaddingAttr.getType(), inputPaddingAttr);
+    DenseI32ArrayAttr inputPaddingVal =
+        rewriter.getDenseI32ArrayAttr(inputPadding);
 
     if (op.getQuantizationInfo().has_value()) {
       auto quantInfo = op.getQuantizationInfo().value();
       input = createOpAndInfer<tosa::PadOp>(
           rewriter, loc, UnrankedTensorType::get(inputETy), input,
-          inputPaddingVal, nullptr,
+          inputPaddingVal, pad_const_attr,
           rewriter.getAttr<PadOpQuantizationAttr>(quantInfo.getInputZp()));
     } else {
-      input = createOpAndInfer<tosa::PadOp>(rewriter, loc,
-                                            UnrankedTensorType::get(inputETy),
-                                            input, inputPaddingVal);
+      input = createOpAndInfer<tosa::PadOp>(
+          rewriter, loc, UnrankedTensorType::get(inputETy), input,
+          inputPaddingVal, pad_const_attr);
     }
 
     // We use a zero bias as we need to broadcast the bias.
     auto zeroBias = rewriter.create<tosa::ConstOp>(
         loc,
         RankedTensorType::get({outputChannels * stride[0] * stride[1]},
                               biasETy),
         DenseElementsAttr::get(
auto slice = createOpAndInfer<tosa::SliceOp>(
                      .getResult();
 
     llvm::SmallVector<int32_t, 8> resultPadding = {0, 0, 0, 0, 0, 0, 0, 0};
     resultPadding[2] = resultPadTop;
     resultPadding[3] = resultTy.getDimSize(1) - resultPadTop - sliceSize[1];
     resultPadding[4] = resultPadLeft;
     resultPadding[5] = resultTy.getDimSize(2) - resultPadLeft - sliceSize[2];
 
-    DenseElementsAttr resultPaddingAttr = DenseIntElementsAttr::get(
-        RankedTensorType::get({4, 2}, rewriter.getI32Type()), resultPadding);
-
-    Value resultPaddingVal = createOpAndInfer<tosa::ConstOp>(
-        rewriter, loc, resultPaddingAttr.getType(), resultPaddingAttr);
+    DenseI32ArrayAttr resultPaddingVal =
+        rewriter.getDenseI32ArrayAttr(resultPadding);
 
     auto resultPad = createOpAndInfer<tosa::PadOp>(
         rewriter, loc, UnrankedTensorType::get(resultETy), slice,
-        resultPaddingVal);
+        resultPaddingVal, pad_const_attr);
 
     rewriter.replaceOpWithNewOp<tosa::AddOp>(op, op.getType(), resultPad, bias);
     return success();
   }
 };
 
 } // namespace
 
 void mlir::tosa::populateTosaDecomposeTransposeConv(
     MLIRContext *ctx, RewritePatternSet &patterns) {
   patterns.add<TransposeConvNonStridedConverter>(ctx);
   patterns.add<TransposeConvStridedConverter>(ctx);
 }

mlir/test/Conversion/TosaToTensor/tosa-to-tensor.mlir

func.func @slice_dyn(%arg0: tensor<?xf32>) -> (tensor<?xf32>) {
   return %0 : tensor<?xf32>
 }
 
 // -----
 
 // CHECK-LABEL: @pad_float
 // CHECK-SAME: (%[[ARG0:[0-9a-zA-Z_]*]]:
 func.func @pad_float(%arg0 : tensor<1x2xf32>) -> (tensor<4x9xf32>) {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
   // TODO: Output contains multiple "arith.constant 1 : index".
   // CHECK-DAG: [[INDEX1:%.+]] = arith.constant 1 : index
   // CHECK-DAG: [[INDEX2:%.+]] = arith.constant 2 : index
   // CHECK-DAG: [[INDEX3:%.+]] = arith.constant 3 : index
   // CHECK-DAG: [[INDEX4:%.+]] = arith.constant 4 : index
   // CHECK-DAG: [[CST:%.+]] = arith.constant 0.000000e+00 : f32
   // CHECK: tensor.pad %[[ARG0]] low{{\[}}%{{.*}}, [[INDEX3]]] high{{\[}}[[INDEX2]], [[INDEX4]]]  {
   // CHECK:   tensor.yield [[CST]]
   // CHECK: } : tensor<1x2xf32> to tensor<4x9xf32>
-  %1 = "tosa.pad"(%arg0, %0)  : (tensor<1x2xf32>, tensor<2x2xi32>)  -> (tensor<4x9xf32>)
-  return %1 : tensor<4x9xf32>
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: 1, 2, 3, 4>} : (tensor<1x2xf32>)  -> (tensor<4x9xf32>)
+  return %0 : tensor<4x9xf32>
 }
 
 func.func @pad_int(%arg0 : tensor<1x2xi32>) -> (tensor<4x9xi32>) {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
   // CHECK: [[CST:%.+]] = arith.constant 0 : i32
   // CHECK: tensor.pad
   // CHECK:   tensor.yield [[CST]]
-  %1 = "tosa.pad"(%arg0, %0)  : (tensor<1x2xi32>, tensor<2x2xi32>)  -> (tensor<4x9xi32>)
-  return %1 : tensor<4x9xi32>
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: 1, 2, 3, 4>} : (tensor<1x2xi32>)  -> (tensor<4x9xi32>)
+  return %0 : tensor<4x9xi32>
 }
 
 func.func @pad_quant(%arg0 : tensor<1x2xi32>) -> (tensor<4x9xi32>) {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
   // CHECK: [[CST:%.+]] = arith.constant 42 : i32
   // CHECK: tensor.pad
   // CHECK:   tensor.yield [[CST]]
-  %1 = "tosa.pad"(%arg0, %0) {quantization_info = #tosa.pad_quant<input_zp = 42>} : (tensor<1x2xi32>, tensor<2x2xi32>)  -> (tensor<4x9xi32>)
-  return %1 : tensor<4x9xi32>
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: 1, 2, 3, 4>, quantization_info = #tosa.pad_quant<input_zp = 42>} : (tensor<1x2xi32>)  -> (tensor<4x9xi32>)
+  return %0 : tensor<4x9xi32>
 }
 
 // -----
 
 func.func @pad_float_explicit(%arg0 : tensor<1x2xf32>) -> (tensor<4x9xf32>) {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
   // TODO: Output contains multiple "arith.constant 1 : index".
   // CHECK-DAG: [[INDEX1:%.+]] = arith.constant 1 : index
   // CHECK-DAG: [[INDEX2:%.+]] = arith.constant 2 : index
   // CHECK-DAG: [[INDEX3:%.+]] = arith.constant 3 : index
   // CHECK-DAG: [[INDEX4:%.+]] = arith.constant 4 : index
   // CHECK-DAG: [[CST:%.+]] = arith.constant 4.200000e+01 : f32
   // CHECK: tensor.pad %[[ARG0]] low{{\[}}%{{.*}}, [[INDEX3]]] high{{\[}}[[INDEX2]], [[INDEX4]]]  {
   // CHECK:   tensor.yield [[CST]]
   // CHECK: } : tensor<1x2xf32> to tensor<4x9xf32>
-  %1 = arith.constant dense<42.0> : tensor<f32>
-  %2 = "tosa.pad"(%arg0, %0, %1)  : (tensor<1x2xf32>, tensor<2x2xi32>, tensor<f32>)  -> (tensor<4x9xf32>)
-  return %2 : tensor<4x9xf32>
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<42.0> : tensor<f32>, padding = array<i32: 1, 2, 3, 4>} : (tensor<1x2xf32>) -> tensor<4x9xf32>
+  return %0 : tensor<4x9xf32>
 }
 
 // -----
 
 func.func @pad_dyn_input(%arg0 : tensor<?x2xf32>) -> (tensor<?x9xf32>) {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
   // TODO: Output contains multiple "arith.constant 1 : index".
   // CHECK-DAG: [[INDEX1:%.+]] = arith.constant 1 : index
   // CHECK-DAG: [[INDEX2:%.+]] = arith.constant 2 : index
   // CHECK-DAG: [[INDEX3:%.+]] = arith.constant 3 : index
   // CHECK-DAG: [[INDEX4:%.+]] = arith.constant 4 : index
   // CHECK-DAG: [[CST:%.+]] = arith.constant 0.000000e+00 : f32
   // CHECK: tensor.pad %[[ARG0]] low{{\[}}%{{.*}}, [[INDEX3]]] high{{\[}}[[INDEX2]], [[INDEX4]]]  {
   // CHECK:   tensor.yield [[CST]]
   // CHECK: } : tensor<?x2xf32> to tensor<?x9xf32>
-  %1 = "tosa.pad"(%arg0, %0)  : (tensor<?x2xf32>, tensor<2x2xi32>)  -> (tensor<?x9xf32>)
-  return %1 : tensor<?x9xf32>
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: 1, 2, 3, 4>} : (tensor<?x2xf32>) -> tensor<?x9xf32>
+  return %0 : tensor<?x9xf32>
 }
 
 func.func @pad_dyn_padding(%arg0 : tensor<1x2xf32>) -> (tensor<?x9xf32>) {
-  %0 = arith.constant dense<[[-1, 2], [3, 4]]> : tensor<2x2xi32>
   // TODO: Output contains multiple "arith.constant 1 : index".
   // CHECK-DAG: [[INDEX1:%.+]] = arith.constant 1 : index
   // CHECK-DAG: [[INDEX2:%.+]] = arith.constant 2 : index
   // CHECK-DAG: [[INDEX3:%.+]] = arith.constant 3 : index
   // CHECK-DAG: [[INDEX4:%.+]] = arith.constant 4 : index
   // CHECK-DAG: [[CST:%.+]] = arith.constant 0.000000e+00 : f32
   // CHECK: tensor.pad %[[ARG0]] low{{\[}}%{{.*}}, [[INDEX3]]] high{{\[}}[[INDEX2]], [[INDEX4]]]  {
   // CHECK:   tensor.yield [[CST]]
   // CHECK: } : tensor<1x2xf32> to tensor<?x9xf32>
-  %1 = "tosa.pad"(%arg0, %0)  : (tensor<1x2xf32>, tensor<2x2xi32>)  -> (tensor<?x9xf32>)
-  return %1 : tensor<?x9xf32>
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: -1, 2, 3, 4>} : (tensor<1x2xf32>) -> tensor<?x9xf32>
+  return %0 : tensor<?x9xf32>
 }

mlir/test/Dialect/Tosa/canonicalize.mlir

func.func @max_pool2d_is_noop(%arg0: tensor<10x1x1x3xf32>) -> tensor<10x1x1x3xf32> {
   // CHECK: return %arg0
   %0 = "tosa.max_pool2d"(%arg0) {kernel = array<i64: 1, 1>, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1>} : (tensor<10x1x1x3xf32>) -> tensor<10x1x1x3xf32>
   return %0 : tensor<10x1x1x3xf32>
 }
 
 // CHECK-LABEL: @pad_noop
 func.func @pad_noop(%arg0: tensor<?x?xf32>) -> tensor<?x?xf32> {
   // CHECK: return %arg0
-  %0 = "tosa.const"() { value = dense<0> : tensor<2x2xi32>} : () -> tensor<2x2xi32>
-  %1 = "tosa.pad"(%arg0, %0) : (tensor<?x?xf32>, tensor<2x2xi32>) -> tensor<?x?xf32>
-  return %1 : tensor<?x?xf32>
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<0.0> : tensor<f32>, padding = array<i32: 0, 0, 0, 0>} : (tensor<?x?xf32>) -> tensor<?x?xf32>
+  return %0 : tensor<?x?xf32>
 }
 
 // CHECK-LABEL: @pad_determine_val_i32
-func.func @pad_determine_val_i32(%arg0: tensor<?x?xi32>, %arg1 : tensor<2x2xi32>) -> tensor<?x?xi32> {
-  // CHECK: %[[ZERO:.+]] = "tosa.const"() {value = dense<0> : tensor<i32>}
-  // CHECK: "tosa.pad"(%arg0, %arg1, %[[ZERO]])
-  %0 = "tosa.const"() { value = dense<[[1, 0], [0, 1]]> : tensor<2x2xi32>} : () -> tensor<2x2xi32>
-  %1 = "tosa.pad"(%arg0, %arg1) : (tensor<?x?xi32>, tensor<2x2xi32>) -> tensor<?x?xi32>
-  return %1 : tensor<?x?xi32>
+func.func @pad_determine_val_i32(%arg0: tensor<?x?xi32>) -> tensor<?x?xi32> {
+  // CHECK: "tosa.pad"(%arg0) {pad_const = dense<11> : tensor<i32>, padding = array<i32: 1, 0, 0, 1>}
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<11> : tensor<i32>, padding = array<i32: 1, 0, 0, 1>} : (tensor<?x?xi32>) -> tensor<?x?xi32>
+  return %0 : tensor<?x?xi32>
 }
 
 // CHECK-LABEL: @pad_determine_val_f32
-func.func @pad_determine_val_f32(%arg0: tensor<?x?xf32>, %arg1 : tensor<2x2xi32>) -> tensor<?x?xf32> {
-  // CHECK: %[[ZERO:.+]] = "tosa.const"() {value = dense<0.000000e+00> : tensor<f32>}
-  // CHECK: "tosa.pad"(%arg0, %arg1, %[[ZERO]])
-  %0 = "tosa.const"() { value = dense<[[1, 0], [0, 1]]> : tensor<2x2xi32>} : () -> tensor<2x2xi32>
-  %1 = "tosa.pad"(%arg0, %arg1) : (tensor<?x?xf32>, tensor<2x2xi32>) -> tensor<?x?xf32>
-  return %1 : tensor<?x?xf32>
+func.func @pad_determine_val_f32(%arg0: tensor<?x?xf32>) -> tensor<?x?xf32> {
+  // CHECK: "tosa.pad"(%arg0) {pad_const = dense<1.230000e+00> : tensor<f32>, padding = array<i32: 1, 0, 0, 1>}
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<1.23> : tensor<f32>, padding = array<i32: 1, 0, 0, 1>} : (tensor<?x?xf32>)  -> (tensor<?x?xf32>)
+  return %0 : tensor<?x?xf32>
 }
 
 // CHECK-LABEL: @pad_determine_val_quant
 func.func @pad_determine_val_quant(%arg0: tensor<?x?xi32>, %arg1 : tensor<2x2xi32>) -> tensor<?x?xi32> {
-  // CHECK: %[[ZERO:.+]] = "tosa.const"() {value = dense<42> : tensor<i32>}
-  // CHECK: "tosa.pad"(%arg0, %arg1, %[[ZERO]])
-  %0 = "tosa.const"() { value = dense<[[1, 0], [0, 1]]> : tensor<2x2xi32>} : () -> tensor<2x2xi32>
-  %1 = "tosa.pad"(%arg0, %arg1) {quantization_info = #tosa.pad_quant<input_zp = 42>} : (tensor<?x?xi32>, tensor<2x2xi32>) -> tensor<?x?xi32>
-  return %1 : tensor<?x?xi32>
+  // CHECK: "tosa.pad"(%arg0) {pad_const = dense<42> : tensor<i32>, padding = array<i32: 1, 0, 0, 1>}
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: 1, 0, 0, 1>, quantization_info = #tosa.pad_quant<input_zp = 42>} : (tensor<?x?xi32>) -> tensor<?x?xi32>
+  return %0 : tensor<?x?xi32>
 }
 
 // CHECK-LABEL: @mul_one_different_shape
 func.func @mul_one_different_shape(%arg0: tensor<2x3xf32>) -> tensor<4x2x3xf32> {
   // CHECK: tosa.mul
   %ones = "tosa.const"() {value = dense<1.0> : tensor<4x2x3xf32>} : () -> tensor<4x2x3xf32>
   %1 = "tosa.mul"(%arg0, %ones) {shift = 0 : i32} : (tensor<2x3xf32>, tensor<4x2x3xf32>) -> tensor<4x2x3xf32>
   return %1 : tensor<4x2x3xf32>

mlir/test/Dialect/Tosa/ops.mlir

 // CHECK-LABEL: concat
 func.func @test_concat(%arg0: tensor<13x21x3xf32>, %arg1: tensor<13x21x3xf32>) -> tensor<26x21x3xf32> {
   %0 = "tosa.concat"(%arg0, %arg1) {axis = 0 : i64} : (tensor<13x21x3xf32>, tensor<13x21x3xf32>) -> tensor<26x21x3xf32>
   return %0 : tensor<26x21x3xf32>
 }
 
 // -----
 // CHECK-LABEL: pad
-func.func @test_pad(%arg0: tensor<13x21x3xf32>, %arg1: tensor<3x2xi32>) -> tensor<13x21x3xf32> {
-  %0 = "tosa.pad"(%arg0, %arg1) : (tensor<13x21x3xf32>, tensor<3x2xi32>) -> tensor<13x21x3xf32>
-  return %0 : tensor<13x21x3xf32>
-}
-
-// -----
-// CHECK-LABEL: pad_explicit_value
-func.func @test_pad_explicit_value(%arg0: tensor<13x21x3xf32>, %arg1: tensor<3x2xi32>) -> tensor<13x21x3xf32> {
-  %0 = "tosa.const"() {value = dense<3.14> : tensor<f32>} : () -> tensor<f32>
-  %1 = "tosa.pad"(%arg0, %arg1, %0) : (tensor<13x21x3xf32>, tensor<3x2xi32>, tensor<f32>) -> tensor<13x21x3xf32>
-  return %1 : tensor<13x21x3xf32>
+func.func @test_pad(%arg0: tensor<5x3x5x3xf32>) -> tensor<5x4x6x3xf32> {
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<3.14> : tensor<f32>, padding = array<i32: 0, 0, 0, 1, 0, 1, 0, 0>} : (tensor<5x3x5x3xf32>) -> tensor<5x4x6x3xf32>
+  return %0 : tensor<5x4x6x3xf32>
 }
 
 // -----
 // CHECK-LABEL: reshape
 func.func @test_reshape(%arg0: tensor<13x21x3xf32>) -> tensor<1x819xf32> {
   %0 = "tosa.reshape"(%arg0) {new_shape = array<i64: 1, 819>} : (tensor<13x21x3xf32>) -> tensor<1x819xf32>
   return %0 : tensor<1x819xf32>
 }

mlir/test/Dialect/Tosa/tosa-decompose-conv2d.mlir

// CHECK:         }
   %0 = "tosa.conv2d"(%arg0, %arg1, %arg2) {dilation = array<i64: 1, 1>, pad = array<i64: 0, 0, 0, 0>, quantization_info = #tosa.conv_quant<input_zp = -6, weight_zp = 11>, stride = array<i64: 1, 1>} : (tensor<?x14x14x64xi8>, tensor<384x1x1x64xi8>, tensor<384xi32>) -> tensor<?x14x14x384xi32>
   return %0 : tensor<?x14x14x384xi32>
 }
 
 // -----
 
 // CHECK-LABEL: @conv2d_as_fully_connected_padded
 func.func @conv2d_as_fully_connected_padded(%arg0: tensor<4x10x10x2xi8>, %arg1: tensor<3x1x1x2xi8>, %arg2: tensor<3xi32>) -> tensor<4x12x12x3xi32> {
-  // CHECK-DAG: %[[PAD_SHAPE:.+]] = "tosa.const"() {value = dense<{{\[\[}}0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<4x2xi64>}
-  // CHECK-DAG: %[[PAD_VAL:.+]] = "tosa.const"() {value = dense<42> : tensor<i8>}
-  // CHECK-DAG: %[[PAD:.+]] = "tosa.pad"(%arg0, %[[PAD_SHAPE]], %[[PAD_VAL]]) : (tensor<4x10x10x2xi8>, tensor<4x2xi64>, tensor<i8>) -> tensor<4x12x12x2xi8>
+  // CHECK-DAG: %[[PAD:.+]] = "tosa.pad"(%arg0) {pad_const = dense<42> : tensor<i8>, padding = array<i32: 0, 0, 1, 1, 1, 1, 0, 0>} : (tensor<4x10x10x2xi8>) -> tensor<4x12x12x2xi8>
   // CHECK-DAG: %[[RESHAPE_INPUT:.+]] = "tosa.reshape"(%[[PAD]]) {new_shape = array<i64: 576, 2>}
   // CHECK-DAG: %[[RESHAPE_FILTER:.+]] = "tosa.reshape"(%arg1) {new_shape = array<i64: 3, 2>}
   // CHECK-DAG: %[[FULLY:.+]] = "tosa.fully_connected"(%[[RESHAPE_INPUT]], %[[RESHAPE_FILTER]], %arg2) {quantization_info = #tosa.conv_quant<input_zp = 42, weight_zp = 24>}
   // CHECK: %[[RESHAPE:.+]] = "tosa.reshape"(%[[FULLY]]) {new_shape = array<i64: 4, 12, 12, 3>}
   %0 = "tosa.conv2d"(%arg0, %arg1, %arg2) {pad = array<i64: 1, 1, 1, 1>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1>, quantization_info = #tosa.conv_quant<input_zp = 42, weight_zp = 24>} : (tensor<4x10x10x2xi8>, tensor<3x1x1x2xi8>, tensor<3xi32>) -> tensor<4x12x12x3xi32>
   return %0 : tensor<4x12x12x3xi32>
 }
+
+// -----
+
+// CHECK-LABEL: @conv2d_as_fully_connected_padded_fp
+func.func @conv2d_as_fully_connected_padded_fp(%arg0: tensor<4x10x10x2xf32>, %arg1: tensor<3x1x1x2xf32>, %arg2: tensor<3xf32>) -> tensor<4x13x13x3xf32> {
+  // CHECK-DAG: %[[PAD:.+]] = "tosa.pad"(%arg0) {pad_const = dense<0.000000e+00> : tensor<f32>, padding = array<i32: 0, 0, 1, 2, 1, 2, 0, 0>} : (tensor<4x10x10x2xf32>) -> tensor<4x13x13x2xf32>
+  // CHECK-DAG: %[[RESHAPE_INPUT:.+]] = "tosa.reshape"(%[[PAD]]) {new_shape = array<i64: 676, 2>}
+  // CHECK-DAG: %[[RESHAPE_FILTER:.+]] = "tosa.reshape"(%arg1) {new_shape = array<i64: 3, 2>}
+  // CHECK-DAG: %[[FULLY:.+]] = "tosa.fully_connected"(%[[RESHAPE_INPUT]], %[[RESHAPE_FILTER]], %arg2)
+  // CHECK: %[[RESHAPE:.+]] = "tosa.reshape"(%[[FULLY]]) {new_shape = array<i64: 4, 13, 13, 3>}
+  %0 = "tosa.conv2d"(%arg0, %arg1, %arg2) {pad = array<i64: 1, 2, 1, 2>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1>} : (tensor<4x10x10x2xf32>, tensor<3x1x1x2xf32>, tensor<3xf32>) -> tensor<4x13x13x3xf32>
+  return %0 : tensor<4x13x13x3xf32>
+}

mlir/test/Dialect/Tosa/tosa-decompose-depthwise.mlir

func.func @depthwise_conv2d_as_mul_q(%arg0: tensor<4x10x10x2xi8>, %arg1: tensor<1x1x2x3xi8>, %arg2: tensor<6xi32>) -> tensor<4x10x10x6xi32> {
   // CHECK: %[[sWe:.+]] = "tosa.sub"(%[[cWe]], %[[wZp]])
   // CHECK: %[[mul:.+]] = "tosa.mul"(%[[sIn]], %[[sWe]]) {shift = 0 : i32}
   // CHECK: %[[reO:.+]] = "tosa.reshape"(%[[mul]]) {new_shape = array<i64: 4, 10, 10, 6>}
   // CHECK: %[[add:.+]] = "tosa.add"(%[[reO]], %arg2)
   %0 = "tosa.depthwise_conv2d"(%arg0, %arg1, %arg2) {pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1>, quantization_info = #tosa.conv_quant<input_zp = 7, weight_zp = 11>} : (tensor<4x10x10x2xi8>, tensor<1x1x2x3xi8>, tensor<6xi32>) -> tensor<4x10x10x6xi32>
   return %0 : tensor<4x10x10x6xi32>
 }
 
+
 // -----
 
 // CHECK-LABEL: @depthwise_conv2d_as_mul_padded
 func.func @depthwise_conv2d_as_mul_padded(%arg0: tensor<4x10x10x2xf32>, %arg1: tensor<1x1x2x3xf32>, %arg2: tensor<6xf32>) -> tensor<4x12x12x6xf32> {
-  // CHECK: %[[pad:.+]] = "tosa.const"() {value = dense<{{\[\[}}0, 0], [1, 1], [1, 1], [0, 0], [0, 0]]> : tensor<5x2xi64>}
-  // CHECK: %[[zero:.+]] = "tosa.const"() {value = dense<0.000000e+00> : tensor<f32>}
   // CHECK: %[[reIn:.+]] = "tosa.reshape"(%arg0) {new_shape = array<i64: 4, 10, 10, 2, 1>}
-  // CHECK: %[[padded:.+]] = "tosa.pad"(%[[reIn]], %[[pad]], %[[zero]]) : (tensor<4x10x10x2x1xf32>, tensor<5x2xi64>, tensor<f32>) -> tensor<4x12x12x2x1xf32>
-  // CHECK: %[[mul:.+]] = "tosa.mul"(%3, %arg1) {shift = 0 : i32}
+  // CHECK: %[[padded:.+]] = "tosa.pad"(%[[reIn]]) {pad_const = dense<0.000000e+00> : tensor<f32>, padding = array<i32: 0, 0, 1, 1, 1, 1, 0, 0, 0, 0>} : (tensor<4x10x10x2x1xf32>) -> tensor<4x12x12x2x1xf32>
+  // CHECK: %[[mul:.+]] = "tosa.mul"(%[[padded]], %arg1) {shift = 0 : i32}
   // CHECK: %[[reOut:.+]] = "tosa.reshape"(%[[mul]]) {new_shape = array<i64: 4, 12, 12, 6>}
   // CHECK: %[[add:.+]] = "tosa.add"(%[[reOut]], %arg2)
   %0 = "tosa.depthwise_conv2d"(%arg0, %arg1, %arg2) {pad = array<i64: 1, 1, 1, 1>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1>} : (tensor<4x10x10x2xf32>, tensor<1x1x2x3xf32>, tensor<6xf32>) -> tensor<4x12x12x6xf32>
   return %0 : tensor<4x12x12x6xf32>
 }

mlir/test/Dialect/Tosa/tosa-decompose-transpose-conv.mlir

func.func @transpose_conv2d_quantized_padded(%arg0: tensor<2x16x14x3xi8>, %arg1: tensor<5x3x6x3xi8>, %arg2: tensor<5xi32>) -> (tensor<2x21x26x5xi32>) {
   return %0 : tensor<2x21x26x5xi32>
 }
 
 // -----
 
 // CHECK-LABEL: @transpose_conv2d_strided
 func.func @transpose_conv2d_strided(%arg0: tensor<2x17x15x3xf32>, %arg1: tensor<5x3x5x3xf32>, %arg2: tensor<5xf32>) -> tensor<2x?x?x5xf32> {
   // Manipulate the weight matrix to handle striding.
-  // CHECK-DAG: %[[PADV:.+]]  = "tosa.const"() {value = dense<{{\[\[}}0, 0], [0, 1], [0, 1], [0, 0]]> : tensor<4x2xi32>}
   // CHECK-DAG: %[[TRANSV:.+]]  = "tosa.const"() {value = dense<[2, 4, 0, 1, 3, 5]> : tensor<6xi32>}
-  // CHECK-DAG: %[[PADW:.+]]  = "tosa.pad"(%arg1, %[[PADV]])
+  // CHECK-DAG: %[[PADW:.+]]  = "tosa.pad"(%arg1) {pad_const = dense<0.000000e+00> : tensor<f32>, padding = array<i32: 0, 0, 0, 1, 0, 1, 0, 0>} : (tensor<5x3x5x3xf32>) -> tensor<5x4x6x3xf32>
   // CHECK-DAG: %[[RESW1:.+]]  = "tosa.reshape"(%[[PADW]]) {new_shape = array<i64: 5, 2, 2, 2, 3, 3>}
   // CHECK-DAG: %[[TRANS:.+]]  = "tosa.transpose"(%[[RESW1]], %[[TRANSV]])
   // CHECK-DAG: %[[RESW2:.+]]  = "tosa.reshape"(%[[TRANS]]) {new_shape = array<i64: 30, 2, 2, 3>}
   // CHECK-DAG: %[[REV1:.+]]  = "tosa.reverse"(%[[RESW2]]) {axis = 1 : i64}
   // CHECK-DAG: %[[NEWWEIGHT:.+]] = "tosa.reverse"(%[[REV1]]) {axis = 2 : i64}
 
   // Pad out the input matrix to handle the transpose conv.
-  // CHECK-DAG: %[[PAD:.+]]  = "tosa.const"() {value = dense<{{\[\[}}0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<4x2xi32>}
   // CHECK-DAG: %[[TRANS2:.+]]  = "tosa.const"() {value = dense<[0, 1, 3, 2, 4, 5]> : tensor<6xi32>}
-  // CHECK-DAG: %[[NEWINPUT:.+]] = "tosa.pad"(%arg0, %[[PAD]])
+  // CHECK-DAG: %[[NEWINPUT:.+]] = "tosa.pad"(%arg0) {pad_const = dense<0.000000e+00> : tensor<f32>, padding = array<i32: 0, 0, 1, 1, 1, 1, 0, 0>} : (tensor<2x17x15x3xf32>) -> tensor<2x19x17x3xf32>
 
   // Manipulate the final shape.
   // CHECK-DAG: %[[BIAS:.+]]  = "tosa.const"() {value = dense<0.000000e+00> : tensor<30xf32>}
   // CHECK-DAG: %[[CONV:.+]] = "tosa.conv2d"(%[[NEWINPUT]], %[[NEWWEIGHT]], %[[BIAS]]) {dilation = array<i64: 1, 1>, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>}
   // CHECK-DAG: %[[RESHAPE_OUT_1:.+]] = "tosa.reshape"(%[[CONV]]) {new_shape = array<i64: 2, 18, 16, 2, 3, 5>}
   // CHECK-DAG: %[[TRANS_OUT:.+]] = "tosa.transpose"(%[[RESHAPE_OUT_1]], %[[TRANS2]])
   // CHECK-DAG: %[[RESHAPE_OUT_2:.+]] = "tosa.reshape"(%[[TRANS_OUT]]) {new_shape = array<i64: 2, 36, 48, 5>}
   // CHECK-DAG: %[[SLICE:.+]] = "tosa.slice"(%[[RESHAPE_OUT_2]]) {size = array<i64: 2, 35, 47, 5>, start = array<i64: 0, 0, 0, 0>}
   // CHECK: %[[ADD:.+]] = "tosa.add"(%[[SLICE]], %arg2)
   %0 = "tosa.transpose_conv2d"(%arg0, %arg1, %arg2) {out_pad = array<i64: 0, 0, 0, 0>, out_shape = array<i64: -1, -1, -1, -1>, stride = array<i64: 2, 3>} : (tensor<2x17x15x3xf32>, tensor<5x3x5x3xf32>, tensor<5xf32>) -> tensor<2x35x47x5xf32>
   %1 = tensor.cast %0 : tensor<2x35x47x5xf32> to tensor<2x?x?x5xf32>
   return %1 : tensor<2x?x?x5xf32>
 }
 
 // -----
 
 // CHECK-LABEL: @transpose_conv2d_strided_quantized
 func.func @transpose_conv2d_strided_quantized(%arg0: tensor<2x17x15x3xi8>, %arg1: tensor<5x3x5x3xi8>, %arg2: tensor<5xi32>) -> (tensor<2x35x47x5xi32>) {
   // Manipulate the weight matrix to handle striding.
-  // CHECK-DAG: %[[PADV:.+]]  = "tosa.const"() {value = dense<{{\[\[}}0, 0], [0, 1], [0, 1], [0, 0]]> : tensor<4x2xi32>}
   // CHECK-DAG: %[[TRANSV:.+]]  = "tosa.const"() {value = dense<[2, 4, 0, 1, 3, 5]> : tensor<6xi32>}
-  // CHECK-DAG: %[[PADW:.+]]  = "tosa.pad"(%arg1, %[[PADV]]) {quantization_info = #tosa.pad_quant<input_zp = 42>}
+  // CHECK-DAG: %[[PADW:.+]]  = "tosa.pad"(%arg1) {pad_const = dense<0> : tensor<i8>, padding = array<i32: 0, 0, 0, 1, 0, 1, 0, 0>, quantization_info = #tosa.pad_quant<input_zp = 42>} : (tensor<5x3x5x3xi8>) -> tensor<5x4x6x3xi8>
   // CHECK-DAG: %[[RESW1:.+]]  = "tosa.reshape"(%[[PADW]]) {new_shape = array<i64: 5, 2, 2, 2, 3, 3>}
   // CHECK-DAG: %[[TRANS:.+]]  = "tosa.transpose"(%[[RESW1]], %[[TRANSV]])
   // CHECK-DAG: %[[RESW2:.+]]  = "tosa.reshape"(%[[TRANS]]) {new_shape = array<i64: 30, 2, 2, 3>}
   // CHECK-DAG: %[[REV1:.+]]  = "tosa.reverse"(%[[RESW2]]) {axis = 1 : i64}
   // CHECK-DAG: %[[NEWWEIGHT:.+]] = "tosa.reverse"(%[[REV1]]) {axis = 2 : i64}
 
   // Pad out the input matrix to handle the transpose conv.
-  // CHECK-DAG: %[[PAD:.+]]  = "tosa.const"() {value = dense<{{\[\[}}0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<4x2xi32>}
   // CHECK-DAG: %[[TRANS2:.+]]  = "tosa.const"() {value = dense<[0, 1, 3, 2, 4, 5]> : tensor<6xi32>}
-  // CHECK-DAG: %[[NEWINPUT:.+]] = "tosa.pad"(%arg0, %[[PAD]]) {quantization_info = #tosa.pad_quant<input_zp = -22>}
+  // CHECK-DAG: %[[NEWINPUT:.+]] = "tosa.pad"(%arg0) {pad_const = dense<0> : tensor<i8>, padding = array<i32: 0, 0, 1, 1, 1, 1, 0, 0>, quantization_info = #tosa.pad_quant<input_zp = -22>} : (tensor<2x17x15x3xi8>) -> tensor<2x19x17x3xi8>
 
   // Manipulate the final shape.
   // CHECK-DAG: %[[BIAS:.+]]  = "tosa.const"() {value = dense<0> : tensor<30xi32>}
   // CHECK-DAG: %[[CONV:.+]] = "tosa.conv2d"(%[[NEWINPUT]], %[[NEWWEIGHT]], %[[BIAS]]) {dilation = array<i64: 1, 1>, pad = array<i64: 0, 0, 0, 0>, quantization_info = #tosa.conv_quant<input_zp = -22, weight_zp = 42>, stride = array<i64: 1, 1>}
   // CHECK-DAG: %[[RESHAPE_OUT_1:.+]] = "tosa.reshape"(%[[CONV]]) {new_shape = array<i64: 2, 18, 16, 2, 3, 5>}
   // CHECK-DAG: %[[TRANS_OUT:.+]] = "tosa.transpose"(%[[RESHAPE_OUT_1]], %[[TRANS2]])
   // CHECK-DAG: %[[RESHAPE_OUT_2:.+]] = "tosa.reshape"(%[[TRANS_OUT]]) {new_shape = array<i64: 2, 36, 48, 5>}
   // CHECK-DAG: %[[SLICE:.+]] = "tosa.slice"(%[[RESHAPE_OUT_2]]) {size = array<i64: 2, 35, 47, 5>, start = array<i64: 0, 0, 0, 0>}
   // CHECK: %[[ADD:.+]] = "tosa.add"(%[[SLICE]], %arg2)
   %0 = "tosa.transpose_conv2d"(%arg0, %arg1, %arg2) {out_pad = array<i64: 0, 0, 0, 0>, quantization_info = #tosa.conv_quant<input_zp = -22, weight_zp = 42>, out_shape = array<i64: -1, -1, -1, -1>, stride = array<i64: 2, 3>} : (tensor<2x17x15x3xi8>, tensor<5x3x5x3xi8>, tensor<5xi32>) -> tensor<2x35x47x5xi32>
   return %0 : tensor<2x35x47x5xi32>
 }
 
 // -----
 
 // CHECK-LABEL: @transpose_conv2d_strided_overpad
 func.func @transpose_conv2d_strided_overpad(%arg0 : tensor<1x16x1x1xi8>, %arg1 : tensor<1x2x1x1xi8>, %arg2 : tensor<1xi32>) -> (tensor<1x19x2x1xi32>) {
-  // CHECK: %[[WEIGHT_PAD:.+]] = "tosa.const"() 
-  // CHECK-SAME{literal}: value = dense<[[0, 0], [0, 0], [0, 1], [0, 0]]> : tensor<4x2xi32>
   // CHECK: %[[WEIGHT_PERMS:.+]] = "tosa.const"() {value = dense<[2, 4, 0, 1, 3, 5]> : tensor<6xi32>} : () -> tensor<6xi32>
-  // CHECK: %[[INPUT_PAD:.+]] = "tosa.const"() 
-  // CHECK-SAME{literal}: value = dense<[[0, 0], [1, 1], [0, 0], [0, 0]]> : tensor<4x2xi32>}
   // CHECK: %[[ZERO:.+]] = "tosa.const"() {value = dense<0> : tensor<2xi32>} : () -> tensor<2xi32>
   // CHECK: %[[RESULT_PERMS:.+]] = "tosa.const"() {value = dense<[0, 1, 3, 2, 4, 5]> : tensor<6xi32>}
-  // CHECK: %[[RESULT_PAD:.+]] = "tosa.const"() 
-  // CHECK-SAME{literal}: value = dense<[[0, 0], [2, 0], [0, 0], [0, 0]]> : tensor<4x2xi32>}
-  // CHECK: %[[PAD_WEIGHT:.+]] = "tosa.pad"(%arg1, %[[WEIGHT_PAD]]) {quantization_info = #tosa.pad_quant<input_zp = 93>}
+  // CHECK: %[[PAD_WEIGHT:.+]] = "tosa.pad"(%arg1) {pad_const = dense<0> : tensor<i8>, padding = array<i32: 0, 0, 0, 0, 0, 1, 0, 0>, quantization_info = #tosa.pad_quant<input_zp = 93>} : (tensor<1x2x1x1xi8>) -> tensor<1x2x2x1xi8>
   // CHECK: %[[RESHAPE_WEIGHT_0:.+]] = "tosa.reshape"(%[[PAD_WEIGHT]]) {new_shape = array<i64: 1, 2, 1, 1, 2, 1>}
   // CHECK: %[[TRANSPOSE_WEIGHT:.+]] = "tosa.transpose"(%[[RESHAPE_WEIGHT_0]], %[[WEIGHT_PERMS]])
   // CHECK: %[[RESHAPE_WEIGHT_1:.+]] = "tosa.reshape"(%[[TRANSPOSE_WEIGHT]]) {new_shape = array<i64: 2, 2, 1, 1>}
   // CHECK: %[[REVERSE:.+]] = "tosa.reverse"(%[[RESHAPE_WEIGHT_1]]) {axis = 1 : i64}
-  // CHECK: %[[PAD_INPUT:.+]] = "tosa.pad"(%arg0, %[[INPUT_PAD]]) {quantization_info = #tosa.pad_quant<input_zp = -103>}
+  // CHECK: %[[PAD_INPUT:.+]] = "tosa.pad"(%arg0) {pad_const = dense<0> : tensor<i8>, padding = array<i32: 0, 0, 1, 1, 0, 0, 0, 0>, quantization_info = #tosa.pad_quant<input_zp = -103>} : (tensor<1x16x1x1xi8>) -> tensor<1x18x1x1xi8>
   // CHECK: %[[CONV:.+]] = "tosa.conv2d"(%[[PAD_INPUT]], %[[REVERSE]], %[[ZERO]]) 
   // CHECK-SAME{literal}: dilation = [1, 1], pad = [0, 0, 0, 0], quantization_info = #tosa.conv_quant<input_zp = -103, weight_zp = 93>, stride = [1, 1]}
   // CHECK: %[[RESHAPE_RESULT_0:.+]] = "tosa.reshape"(%[[CONV]]) {new_shape = array<i64: 1, 17, 1, 1, 2, 1>}
   // CHECK: %[[TRANSPOSE_RESULT:.+]] = "tosa.transpose"(%[[RESHAPE_RESULT_0]], %[[RESULT_PERMS]])
   // CHECK: %[[RESHAPE_RESULT_1:.+]] = "tosa.reshape"(%[[TRANSPOSE_RESULT]]) {new_shape = array<i64: 1, 17, 2, 1>}
-  // CHECK: %[[PAD_RESULT:.+]] = "tosa.pad"(%[[RESHAPE_RESULT_1]], %[[RESULT_PAD]])
+  // CHECK: %[[PAD_RESULT:.+]] = "tosa.pad"(%[[RESHAPE_RESULT_1]]) {pad_const = dense<0> : tensor<i8>, padding = array<i32: 0, 0, 2, 0, 0, 0, 0, 0>} : (tensor<1x17x2x1xi32>) -> tensor<1x19x2x1xi32>
   // CHECK: %[[ADD:.+]] = "tosa.add"(%[[PAD_RESULT]], %arg2)
   %2 =  "tosa.transpose_conv2d"(%arg0, %arg1, %arg2)  {
     out_pad = array<i64: 2, 0, 0, 1>,
     out_shape = array<i64: 1, -1, -1, 1>,
     stride = array<i64: 1, 2>,
     quantization_info = #tosa.conv_quant<input_zp = -103, weight_zp = 93>} :
     (tensor<1x16x1x1xi8>, tensor<1x2x1x1xi8>, tensor<1xi32>) -> (tensor<1x19x2x1xi32>)
   "func.return" (%2) : (tensor<1x19x2x1xi32>) -> ()
 }

mlir/test/Dialect/Tosa/tosa-infer-shapes.mlir

func.func @test_concat_failure(%arg0 : tensor<2x1xf32>, %arg1 : tensor<2x2xf32>) -> () {
   %0 = "tosa.concat"(%arg0, %arg1) {axis = 0 : i64} : (tensor<2x1xf32>, tensor<2x2xf32>) -> tensor<?x?xf32>
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: @test_padding_no_const
-func.func @test_padding_no_const(%arg0 : tensor<1x2xf32>, %arg1 : tensor<2x2xi32>) -> () {
-  // CHECK: "tosa.pad"(%arg0, %arg1) : (tensor<1x2xf32>, tensor<2x2xi32>) -> tensor<?x?xf32>
-  %0 = "tosa.pad"(%arg0, %arg1)  : (tensor<1x2xf32>, tensor<2x2xi32>)  -> (tensor<?x?xf32>)
+func.func @test_padding_no_const(%arg0 : tensor<1x2xf32>) -> () {
+  // CHECK: "tosa.pad"(%arg0) {padding = array<i32: 0, 0, 0, 1>} : (tensor<1x2xf32>) -> tensor<1x3xf32>
+  %0 = "tosa.pad"(%arg0) {padding = array<i32: 0, 0, 0, 1>} : (tensor<1x2xf32>)  -> (tensor<?x?xf32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL:@test_padding_dynamic_input
 func.func @test_padding_dynamic_input(%arg0 : tensor<1x?xf32>) -> () {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
-  // CHECK: "tosa.pad"(%arg0, %cst) : (tensor<1x?xf32>, tensor<2x2xi32>) -> tensor<4x?xf32>
-  %1 = "tosa.pad"(%arg0, %0)  : (tensor<1x?xf32>, tensor<2x2xi32>)  -> (tensor<?x?xf32>)
+  // CHECK: "tosa.pad"(%arg0) {pad_const = dense<1.000000e+00> : tensor<f32>, padding = array<i32: 1, 0, 1, 0>} : (tensor<1x?xf32>) -> tensor<2x?xf32>
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<1.0> : tensor<f32>, padding = array<i32: 1, 0, 1, 0>} : (tensor<1x?xf32>)  -> (tensor<?x?xf32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @test_padding_simple
 func.func @test_padding_simple(%arg0 : tensor<1x2xf32>) -> () {
-  %0 = arith.constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
-  // CHECK: "tosa.pad"(%arg0, %cst) : (tensor<1x2xf32>, tensor<2x2xi32>) -> tensor<4x9xf32>
-  %1 = "tosa.pad"(%arg0, %0)  : (tensor<1x2xf32>, tensor<2x2xi32>)  -> (tensor<?x?xf32>)
+  // CHECK: "tosa.pad"(%arg0) {pad_const = dense<0> : tensor<i32>, padding = array<i32: 0, 1, 1, 1>} : (tensor<1x2xf32>) -> tensor<2x4xf32>
+  %0 = "tosa.pad"(%arg0) {pad_const = dense<0> : tensor<i32>, padding = array<i32: 0, 1, 1, 1>} : (tensor<1x2xf32>) -> tensor<?x?xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: @test_slice
 func.func @test_slice(%arg0 : tensor<?xi32>) -> () {
   // CHECK: "tosa.slice"(%arg0) {size = array<i64: 2>, start = array<i64: 1>} : (tensor<?xi32>) -> tensor<2xi32>