Support negative padding in constant_pad_nd (pytorch#23116)

### Summary

Fixes pytorch#13554.

Match PyTorch's `constant_pad_nd` behavior for negative padding by
cropping the input before applying positive padding. The optimized
library uses the same portable implementation through its fallback
registration, so both paths receive the fix.

Handle mixed cropping and padding, unchanged output shapes, empty
tensors, fully cropped inputs, dynamic outputs, and channels-last
layouts. Reject excessive cropping and output-dimension overflow, and
ignore unused fill values for crop-only operations as PyTorch does. Add
regression coverage for these cases, including the input from pytorch#13554.

This branch starts at upstream `main` (`283297e430`) and contains only
this fix, without the earlier local commits.

### Test plan

Validation used a fresh runtime build from this branch and a focused
local CMake harness compiling the shared operator tests with generated
portable and optimized bindings.

| Check | Result |
| --- | --- |
| Portable `OpConstantPadNDOutTest` | 32/32 passed |
| Optimized `OpConstantPadNDOutTest` | 31/32 passed; existing
scalar-overflow failure described below |
| PyTorch parity under UBSan, portable and optimized | 3,253 cases per
build passed: 2,803 valid results and 450 expected rejections |
| `clang-format --dry-run --Werror` on the three changed files | Passed
|
| `git diff --check` | Passed |

Commands run against the focused build:

```sh
cmake --build /private/tmp/executorch-pad-pr.r6f52N/tests --parallel 8
ctest --test-dir /private/tmp/executorch-pad-pr.r6f52N/tests --output-on-failure
python .outputs/issue-13554/parity.py \
  /private/tmp/executorch-pad-pr.r6f52N/tests/libportable_parity.dylib \
  /private/tmp/executorch-pad-pr.r6f52N/tests/liboptimized_parity.dylib
```

The optimized `LongTensorTooLargeScalarDies` test fails with the locally
installed PyTorch 2.11 development headers, whose
floating-point-to-int64 overflow check accepts `2^63`. The same failure
was reproduced using the unmodified operator from upstream `main`; the
positive-padding scalar conversion is unchanged by this PR. Portable
tests use the repository's current vendored headers and pass this check.
Full repository CI and lintrunner were not run locally.

Authored with assistance from OpenAI Codex.

Author: JakeStevens

kernels/portable/cpu/op_constant_pad_nd.cpp

@@ -7,7 +7,7 @@
  */
 
 #include <c10/util/irange.h>
-#include <cmath>
+#include <algorithm>
 #include <cstring>
 
 #include <executorch/runtime/kernel/kernel_includes.h>
@@ -32,12 +32,12 @@ template <typename CTYPE>
 void apply_padding_to_dim(
     KernelRuntimeContext& ctx,
     size_t ndim,
+    executorch::aten::ArrayRef<executorch::aten::DimOrderType> dim_order,
     const CTYPE* self_data,
     IntArrayRef self_sizes,
     IntArrayRef self_strides,
     CTYPE* out_data,
     CTYPE* out_data_end,
-    IntArrayRef out_sizes,
     IntArrayRef out_strides,
     IntArrayRef pad,
     const CTYPE value,
@@ -47,25 +47,18 @@ void apply_padding_to_dim(
     return;
   }
 
-  size_t pad_i = ndim - 1 - dim;
+  const size_t logical_dim = dim_order[dim];
+  size_t pad_i = ndim - 1 - logical_dim;
 
   size_t pad_before = 0;
   size_t pad_after = 0;
   if (pad_i < pad.size() / 2) {
-    int64_t pb = pad[2 * pad_i];
-    int64_t pa = pad[2 * pad_i + 1];
-    ET_KERNEL_CHECK_MSG(
-        ctx,
-        pb >= 0 && pa >= 0,
-        InvalidArgument,
-        /* void */,
-        "Padding values must be non-negative.");
-    pad_before = static_cast<size_t>(pb);
-    pad_after = static_cast<size_t>(pa);
+    pad_before = std::max<int64_t>(pad[2 * pad_i], 0);
+    pad_after = std::max<int64_t>(pad[2 * pad_i + 1], 0);
   }
 
-  size_t out_step_len = out_strides[dim];
-  size_t in_step_len = self_strides[dim];
+  size_t out_step_len = out_strides[logical_dim];
+  size_t in_step_len = self_strides[logical_dim];
 
   // Do not copy padding beyond the out tensor bounds.
   // Use division to avoid potential overflow in multiplication.
@@ -92,19 +85,10 @@ void apply_padding_to_dim(
   // If subsequent dims are not padded, then the whole block of memory can be
   // copied.
   if (dim >= last_padded_dim) {
-    size_t copy_len = in_step_len * self_sizes[dim];
+    size_t copy_len = in_step_len * self_sizes[logical_dim];
     size_t copy_nbytes = copy_len * sizeof(CTYPE);
 
     if (copy_nbytes > 0) {
-      // Check that out_data and self_data do not overlap.
-      ET_KERNEL_CHECK_MSG(
-          ctx,
-          out_data != self_data &&
-              ((out_data + copy_len <= self_data) ||
-               (self_data + copy_len <= out_data)),
-          InvalidArgument,
-          /* void */,
-          "Out tensor overlaps with the input tensor. This is not supported.");
       // Bounds check before memcpy
       ET_KERNEL_CHECK_MSG(
           ctx,
@@ -119,23 +103,31 @@ void apply_padding_to_dim(
           InvalidArgument,
           /* void */,
           "Out tensor is too small for the copy operation.");
+      // Check that out_data and self_data do not overlap.
+      ET_KERNEL_CHECK_MSG(
+          ctx,
+          out_data != self_data &&
+              ((out_data + copy_len <= self_data) ||
+               (self_data + copy_len <= out_data)),
+          InvalidArgument,
+          /* void */,
+          "Out tensor overlaps with the input tensor. This is not supported.");
       memcpy(out_data, self_data, copy_nbytes);
       out_data += copy_len;
-      self_data += copy_len;
     }
   }
   // Otherwise, call this function recursively
   else {
-    for (ET_UNUSED const auto i : c10::irange(self_sizes[dim])) {
+    for (const auto i : c10::irange(self_sizes[logical_dim])) {
       apply_padding_to_dim(
           ctx,
           ndim,
+          dim_order,
           self_data,
           self_sizes,
           self_strides,
           out_data,
           out_data_end,
-          out_sizes,
           out_strides,
           pad,
           value,
@@ -147,7 +139,9 @@ void apply_padding_to_dim(
       }
 
       out_data += out_step_len;
-      self_data += in_step_len;
+      if (i + 1 < self_sizes[logical_dim]) {
+        self_data += in_step_len;
+      }
     }
   }
 
@@ -181,6 +175,10 @@ void constant_pad_nd_out_impl(
     IntArrayRef pad,
     CTYPE value_v,
     Tensor& out) {
+  if (out.numel() == 0) {
+    return;
+  }
+
   const CTYPE* self_data = self.const_data_ptr<CTYPE>();
   CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
@@ -193,42 +191,49 @@ void constant_pad_nd_out_impl(
 
   int64_t self_sizes[kTensorDimensionLimit];
   int64_t self_strides[kTensorDimensionLimit];
-  int64_t out_sizes[kTensorDimensionLimit];
   int64_t out_strides[kTensorDimensionLimit];
 
   // Collect sizes and strides of input and output tensors and determine the
   // last padded dimension
   size_t last_padded_dim = 0;
+  size_t input_offset = 0;
   for (const auto i : c10::irange(ndim)) {
-    self_sizes[i] = self.size(i);
-    self_strides[i] = getTrailingDims(self, static_cast<int64_t>(i));
-    out_sizes[i] = out.size(i);
-    out_strides[i] = getTrailingDims(out, static_cast<int64_t>(i));
+    const size_t dim = self.dim_order()[i];
+    self_sizes[dim] = self.size(dim);
+    self_strides[dim] = self.strides()[dim];
+    out_strides[dim] = out.strides()[dim];
 
-    size_t pad_i = ndim - 1 - i;
+    size_t pad_i = ndim - 1 - dim;
     if (pad_i < pad.size() / 2) {
-      if (pad[2 * pad_i] + pad[2 * pad_i + 1] > 0) {
+      const int64_t crop_before = -std::min<int64_t>(pad[2 * pad_i], 0);
+      const int64_t crop_after = -std::min<int64_t>(pad[2 * pad_i + 1], 0);
+      self_sizes[dim] -= crop_before + crop_after;
+      input_offset += crop_before * self_strides[dim];
+      if (pad[2 * pad_i] != 0 || pad[2 * pad_i + 1] != 0) {
         last_padded_dim = i;
       }
     }
+    if (self_sizes[dim] == 0) {
+      set_all_to_value(out_data, out.numel(), value_v);
+      return;
+    }
   }
 
   IntArrayRef self_sizes_ref(self_sizes, ndim);
   IntArrayRef self_strides_ref(self_strides, ndim);
-  IntArrayRef out_sizes_ref(out_sizes, ndim);
   IntArrayRef out_strides_ref(out_strides, ndim);
 
   CTYPE* out_data_end = out_data + out.numel();
 
   apply_padding_to_dim(
       ctx,
       ndim,
-      self_data,
+      self.dim_order(),
+      self_data + input_offset,
       self_sizes_ref,
       self_strides_ref,
       out_data,
       out_data_end,
-      out_sizes_ref,
       out_strides_ref,
       pad,
       value_v,
@@ -244,16 +249,12 @@ Tensor& constant_pad_nd_out(
     IntArrayRef pad,
     const Scalar& value,
     Tensor& out) {
-  (void)ctx;
-
   ET_KERNEL_CHECK(
       ctx, check_constant_pad_args(in, pad, value, out), InvalidArgument, out);
 
   ET_KERNEL_CHECK(
       ctx, tensors_have_same_dim_order(in, out), InvalidArgument, out);
 
-  ET_KERNEL_CHECK(ctx, tensor_is_default_dim_order(in), InvalidArgument, out);
-
   // resize out tensor for dynamic shapes
   ET_KERNEL_CHECK_MSG(
       ctx,
@@ -267,9 +268,12 @@ Tensor& constant_pad_nd_out(
   // @lint-ignore CLANGTIDY facebook-hte-CArray
   static constexpr const char op_name[] = "constant_pad_nd.out";
 
+  const bool has_positive_padding =
+      std::any_of(pad.begin(), pad.end(), [](int64_t p) { return p > 0; });
   ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, op_name, CTYPE, [&]() {
-    auto opt_value_casted =
-        utils::internal::check_overflow_scalar_cast<CTYPE>(value);
+    // PyTorch ignores the fill value when the operation only crops or copies.
+    auto opt_value_casted = utils::internal::check_overflow_scalar_cast<CTYPE>(
+        has_positive_padding ? value : Scalar(0));
     ET_KERNEL_CHECK(ctx, opt_value_casted.has_value(), InvalidArgument, );
     auto value_casted = opt_value_casted.value();
     constant_pad_nd_out_impl<CTYPE>(ctx, in, pad, value_casted, out);

kernels/portable/cpu/util/kernel_ops_util.cpp

@@ -7,7 +7,9 @@
  */
 
 #include <c10/util/irange.h>
+#include <algorithm>
 #include <cstring>
+#include <limits>
 
 #include <executorch/kernels/portable/cpu/util/kernel_ops_util.h>
 #include <executorch/runtime/core/exec_aten/util/tensor_util.h>
@@ -616,12 +618,21 @@ bool check_constant_pad_args(
       pad.size() / 2,
       in.dim());
 
-  for (size_t i = 0; i < pad.size(); ++i) {
-    ET_CHECK_OR_RETURN_FALSE(
-        pad[i] >= 0,
-        "Padding values must be non-negative, but got pad[%zu] = %" PRId64,
-        i,
-        pad[i]);
+  for (const auto i : c10::irange(pad.size() / 2)) {
+    int64_t size = in.size(in.dim() - 1 - i);
+    for (const auto j : c10::irange(2)) {
+      const int64_t crop = std::min<int64_t>(pad[2 * i + j], 0);
+      ET_CHECK_OR_RETURN_FALSE(
+          crop >= -size, "Negative padding exceeds the input dimension.");
+      size += crop;
+    }
+    for (const auto j : c10::irange(2)) {
+      const int64_t padding = std::max<int64_t>(pad[2 * i + j], 0);
+      ET_CHECK_OR_RETURN_FALSE(
+          padding <= std::numeric_limits<Tensor::SizesType>::max() - size,
+          "Padded dimension exceeds the tensor size limit.");
+      size += padding;
+    }
   }
 
   return true;