diff --git a/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp b/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
--- a/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
+++ b/mlir/lib/Dialect/Tensor/IR/TensorOps.cpp
@@ -2839,12 +2839,77 @@
   }
 };
 
+struct FoldStaticPadding : public OpRewritePattern<PadOp> {
+  using OpRewritePattern<PadOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(PadOp padTensorOp,
+                                PatternRewriter &rewriter) const override {
+    Value input = padTensorOp.getSource();
+    if (!input.getType().isa<RankedTensorType>())
+      return failure();
+    auto inputDims = input.getType().cast<RankedTensorType>().getShape();
+    auto inputRank = inputDims.size();
+
+    // Extract the static info from the high and low operands
+    auto operands = padTensorOp.getOperands();
+    SmallVector<int64_t> constOperands;
+    for (auto op : operands) {
+      if (op.getType().isa<TensorType>())
+        continue;
+      APSInt intOp;
+      if (!matchPattern(op, m_ConstantInt(&intOp))) {
+        constOperands.push_back(-1);
+        continue;
+      }
+      constOperands.push_back(intOp.getExtValue());
+    }
+
+    if (!padTensorOp.getResult().getType().isa<RankedTensorType>())
+      return failure();
+    auto outputDims =
+        padTensorOp.getResult().getType().cast<RankedTensorType>().getShape();
+
+    // Verify the op is well-formed
+    if (inputDims.size() != outputDims.size() ||
+        inputDims.size() != (constOperands.size() / 2))
+      return failure();
+
+    auto staticLow = ArrayRef<int64_t>(constOperands.begin(),
+                                       constOperands.begin() + inputRank);
+    auto staticHigh = ArrayRef<int64_t>(constOperands.begin() + inputRank,
+                                        constOperands.end());
+
+    // Calculate the output sizes with the static information
+    SmallVector<int64_t> newOutDims;
+    for (size_t i = 0; i < inputRank; i++)
+      newOutDims.push_back((staticLow[i] < 0 || staticHigh[i] < 0
+                                ? -1
+                                : inputDims[i] + staticLow[i] + staticHigh[i]));
+    if (SmallVector<int64_t>(outputDims) == newOutDims)
+      return failure();
+
+    // Rewrite the op using the new static type
+    auto newResultType = RankedTensorType::get(
+        newOutDims, padTensorOp.getType().getElementType());
+    auto newOp = rewriter.create<PadOp>(
+        padTensorOp->getLoc(), newResultType, input, padTensorOp.getLow(),
+        padTensorOp.getHigh(), staticLow, staticHigh, padTensorOp.getNofold());
+
+    IRMapping mapper;
+    padTensorOp.getRegion().cloneInto(&newOp.getRegion(), mapper);
+    rewriter.replaceOpWithNewOp<tensor::CastOp>(
+        padTensorOp, padTensorOp.getResultType(), newOp);
+
+    return success();
+  }
+};
+
 } // namespace
 
 void PadOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.add<FoldStaticZeroPadding, FoldSourceTensorCast, FoldTargetTensorCast,
-              FoldOrthogonalPaddings>(context);
+              FoldOrthogonalPaddings, FoldStaticPadding>(context);
 }
 
 /// Return the padding value of the PadOp if it constant. In this context,