[OnnxToTorch] Fix AvgPool ceil dynamic result

The static ceil-split branch (count_include_pad, static input) read
the result spatial extent without checking it was static. A
static-input / dynamic-result AveragePool with ceil_mode therefore
hit the kUnknownSize sentinel, computed a negative "extra", skipped
the split, and emitted an ONNX-wrong floor-mode pool. Fold result-dim
dynamism into anyDynamicSpatial so that case routes through the
runtime constant_pad_nd path instead.

Also extract the static split formula into a single staticSplitPad
helper shared by both static call sites, which previously duplicated
it (the divergence above originated from that duplication).

Author: sahas3

lib/Conversion/TorchOnnxToTorch/DefaultDomainAtoF.cpp

@@ -554,13 +554,18 @@ void mlir::torch::onnx_c::populateDefaultDomainAtoF(
         ArrayRef<int64_t> spatialShape =
             inputTensorType.getSizes().drop_front(2);
         auto isDynamicDim = [](int64_t d) { return d == Torch::kUnknownSize; };
-        bool anyDynamicSpatial = llvm::any_of(spatialShape, isDynamicDim);
         // In ceil mode ONNX drops any trailing window that would begin entirely
         // inside the padding. The result type reflects that drop (shape
         // inference applied it), so use it as the output extent -- the injected
         // padding below is sized to reproduce it.
         ArrayRef<int64_t> resultSpatialShape =
             resultType.getSizes().drop_front(2);
+        // The static "bake the split into the pad attr" branch below needs both
+        // the input and the result extent of every spatial dim; if either is
+        // unknown, take the runtime `constant_pad_nd` path (buildSplitPadList
+        // handles the mixed case per dim).
+        bool anyDynamicSpatial = llvm::any_of(spatialShape, isDynamicDim) ||
+                                 llvm::any_of(resultSpatialShape, isDynamicDim);
 
         // Expand a collapsed one-value-per-dim padding (used when the input
         // pads are symmetric) into the explicit per-dim begin/end form the ceil
@@ -573,6 +578,23 @@ void mlir::torch::onnx_c::populateDefaultDomainAtoF(
             pads[i + spatialRank] = pads[i];
         };
 
+        // Resolve the ONNX ceil split for one static spatial dim: the extra
+        // ceil extent (actualPadded - inDim - pBegin - pEnd) is halved onto the
+        // leading edge and the remainder onto the trailing edge. Updates pBegin
+        // / pEnd in place. Kept as the single source of the static split so the
+        // two static call sites below cannot drift (an earlier divergence
+        // between them was a bug). Requires inDim and outDim to be static.
+        auto staticSplitPad = [](int64_t inDim, int64_t outDim, int64_t stride,
+                                 int64_t dilatedKernel, int64_t &pBegin,
+                                 int64_t &pEnd) {
+          int64_t actualPadded = (outDim - 1) * stride + dilatedKernel;
+          int64_t extra = actualPadded - inDim - pBegin - pEnd;
+          if (extra > 0) {
+            pBegin += extra / 2;
+            pEnd += extra - extra / 2;
+          }
+        };
+
         // Build the aten.constant_pad_nd pad list for the ONNX ceil split
         // (begin = p + extra/2, end = p + extra - extra/2), emitted as runtime
         // arithmetic for dynamic dims and constants otherwise. Order is
@@ -590,14 +612,8 @@ void mlir::torch::onnx_c::populateDefaultDomainAtoF(
             int64_t pEndI = normPad[i + spatialRank];
             if (!isDynamicDim(spatialShape[i]) &&
                 !isDynamicDim(resultSpatialShape[i])) {
-              int64_t inDim = spatialShape[i];
-              int64_t outDim = resultSpatialShape[i];
-              int64_t actualPadded = (outDim - 1) * stride + dilatedKernel;
-              int64_t extra = actualPadded - inDim - pBeginI - pEndI;
-              if (extra > 0) {
-                pBeginI += extra / 2;
-                pEndI += extra - extra / 2;
-              }
+              staticSplitPad(spatialShape[i], resultSpatialShape[i], stride,
+                             dilatedKernel, pBeginI, pEndI);
               padPairsFront.push_back(Torch::ConstantIntOp::create(
                   rewriter, loc, rewriter.getI64IntegerAttr(pBeginI)));
               padPairsFront.push_back(Torch::ConstantIntOp::create(
@@ -706,17 +722,9 @@ void mlir::torch::onnx_c::populateDefaultDomainAtoF(
           // attr, then emit floor mode.
           toBeginEndPadding(padding);
           for (int i = 0; i < spatialRank; ++i) {
-            int64_t inDim = spatialShape[i];
             int64_t dilatedKernel = dilations[i] * (kernel[i] - 1) + 1;
-            int64_t &pBegin = padding[i];
-            int64_t &pEnd = padding[i + spatialRank];
-            int64_t outDim = resultSpatialShape[i];
-            int64_t actualPadded = (outDim - 1) * strides[i] + dilatedKernel;
-            int64_t extra = actualPadded - inDim - pBegin - pEnd;
-            if (extra > 0) {
-              pBegin += extra / 2;
-              pEnd += extra - extra / 2;
-            }
+            staticSplitPad(spatialShape[i], resultSpatialShape[i], strides[i],
+                           dilatedKernel, padding[i], padding[i + spatialRank]);
           }
           ceilMode = false;
         } else if (ceilMode && !countIncludePad) {

test/Conversion/TorchOnnxToTorch/simple_ops_a_to_f.mlir

@@ -1002,6 +1002,31 @@ func.func @test_averagepool_2d_ceil_count_include_pad(%arg0: !torch.vtensor<[1,2
 
 // -----
 
+// Static input but a dynamic result extent: the static "bake the split into the
+// pad attr" path cannot size the split (it would read an unknown result dim), so
+// this must fall through to the runtime `constant_pad_nd` + zero-padded,
+// floor-mode pool path -- the same one used when the input is dynamic. The ONNX
+// split pads are still derived at runtime (size.int / ge / Int.bool / sub), and
+// the pool itself carries zero padding, so the original [1,1] pads must NOT
+// appear as the pool's padding arg on %arg0.
+// The input extent is a compile-time constant here (static input), so the split
+// is derived from constant ints -- but still through the runtime drop logic
+// (ge -> Int.bool -> sub), not the static bake-into-attr path.
+// CHECK-LABEL: @test_averagepool_2d_ceil_count_include_pad_static_in_dynamic_out
+// CHECK:         %[[DROP:.*]] = torch.aten.ge.int %{{.*}}, %{{.*}} : !torch.int, !torch.int -> !torch.bool
+// CHECK:         %[[DROPI:.*]] = torch.aten.Int.bool %[[DROP]]
+// CHECK:         %[[PADDED:.*]] = torch.aten.constant_pad_nd %arg0
+// CHECK:         %[[ZEROPAD:.*]] = torch.prim.ListConstruct %int0{{.*}}, %int0{{.*}} : (!torch.int, !torch.int) -> !torch.list<int>
+// CHECK:         %[[CEIL:.*]] = torch.constant.bool false
+// CHECK:         %[[CIP:.*]] = torch.constant.bool true
+// CHECK:         torch.aten.avg_pool2d %[[PADDED]], %{{.*}}, %{{.*}}, %[[ZEROPAD]], %[[CEIL]], %[[CIP]], %none
+func.func @test_averagepool_2d_ceil_count_include_pad_static_in_dynamic_out(%arg0: !torch.vtensor<[1,2,10,11],f32>) -> !torch.vtensor<[1,2,?,?],f32> attributes {torch.onnx_meta.ir_version = 9 : si64, torch.onnx_meta.opset_version = 19 : si64} {
+  %0 = torch.operator "onnx.AveragePool"(%arg0) {torch.onnx.ceil_mode = 1 : si64, torch.onnx.count_include_pad = 1 : si64, torch.onnx.kernel_shape = [3 : si64, 3 : si64], torch.onnx.pads = [1 : si64, 1 : si64, 1 : si64, 1 : si64], torch.onnx.strides = [2 : si64, 2 : si64]} : (!torch.vtensor<[1,2,10,11],f32>) -> !torch.vtensor<[1,2,?,?],f32>
+  return %0 : !torch.vtensor<[1,2,?,?],f32>
+}
+
+// -----
+
 // Same as above but with a dynamic spatial dim: the ONNX ceil split depends on
 // the runtime extent, so it is materialized as a runtime `constant_pad_nd` in
 // front of a zero-padded, floor-mode pool (count_include_pad keeps the injected