@@ -7,6 +7,7 @@
 from typing import Optional
 
 import torch
+from executorch.backends.transforms import get_shape
 from executorch.backends.xnnpack._passes.xnnpack_pass import XNNPACKPass
 from executorch.backends.xnnpack.utils.quant_utils import (
     is_dequant,
@@ -127,15 +128,17 @@ def call(self, graph_module: torch.fx.GraphModule):
         for node in node_list:
             if node.op == "call_function":
                 if node.target.__name__ == "aten.convolution.default":
-                    stride = list(node.args[3])
-                    if len(stride) != 1:
-                        # skip conv if it is not 1d
-                        continue
-
                     kernel_node = node.args[1]
                     if is_dequant(kernel_node) and not is_quant(kernel_node.args[0]):
                         kernel_node = kernel_node.args[0]
 
+                    # The weight rank is the only reliable indicator of the conv
+                    # dimensionality. stride, padding and dilation may each be a
+                    # single value that ATen broadcasts over every spatial dim.
+                    if len(get_shape(kernel_node)) != 3:
+                        # skip conv if it is not 1d
+                        continue
+
                     if not is_param_node(self.exported_program, kernel_node):
                         raise AssertionError(
                             "Expected op for convolution weight node to be a get_attr node or a parameter"
 
@@ -141,8 +141,14 @@ def define_node(
         padding = cast(List[int], node.args[4])
         dilation = cast(List[int], node.args[5])
         output_padding = cast(List[int], node.args[7])
+        # ATen broadcasts a single spatial value over every spatial dim, so any of
+        # these may arrive with length 1 for a 2d convolution.
+        if len(stride) == 1:
+            stride = stride + stride
         if len(padding) == 1:
             padding = padding + padding
+        if len(dilation) == 1:
+            dilation = dilation + dilation
         if len(output_padding) == 1:
             output_padding = output_padding + output_padding
 
 
@@ -361,21 +361,23 @@ def check_constraints(self, node: torch.fx.Node, ep: ExportedProgram) -> bool:
         if not super().check_constraints(node, ep):
             return False
 
-        conv_stride = cast(List[int], node.args[3])
-        if len(conv_stride) > 2:
+        kernel_node = get_input_node(node, 1)
+        kernel_shape = get_shape(kernel_node)
+        # The weight rank is the only reliable indicator of the conv dimensionality.
+        # stride, padding and dilation may each be a single value that ATen
+        # broadcasts over every spatial dim.
+        conv_dim = len(kernel_shape) - 2
+        if conv_dim > 2:
             why(node, "Only support 1D + 2D Conv")
             return False  # Only support 1D + 2D Conv
 
-        kernel_node = get_input_node(node, 1)
-        kernel_shape = get_shape(kernel_node)
         weight_quant_params = QuantParams.from_weights(kernel_node, ep)
         groups = cast(int, node.args[8])
         is_transpose = node.args[6]
 
         # XNNPACK does not support dynamic quantization convs that are not 2D or are depthwise
         if self._detect_precision(node) == ConfigPrecisionType.DYNAMIC_QUANT and (
-            len(conv_stride) != 2
-            or is_depthwise_conv(kernel_shape, groups, is_transpose)
+            conv_dim != 2 or is_depthwise_conv(kernel_shape, groups, is_transpose)
         ):
             why(
                 node,
@@ -409,9 +411,9 @@ def _get_act_deps(
             and act_input.target == exir_ops.edge.aten.constant_pad_nd.default
             and len(act_input.users) == 1
         ):
-            conv_padding = cast(List[int], node.args[4])
-            is_1d = len(conv_padding) == 1
-            is_2d = len(conv_padding) == 2
+            conv_dim = len(get_shape(get_input_node(node, 1))) - 2
+            is_1d = conv_dim == 1
+            is_2d = conv_dim == 2
 
             pad_value = (
                 cast(float, act_input.args[2]) if len(act_input.args) > 2 else 0.0
 
@@ -173,6 +173,18 @@ def get_inputs(self):
         return (torch.randn(2, 2, 4, 4),)
 
 
+class Conv3d(torch.nn.Module):
+    def __init__(self, stride):
+        super().__init__()
+        self.conv = torch.nn.Conv3d(2, 2, (2, 2, 2), stride=stride)
+
+    def forward(self, x):
+        return self.conv(x)
+
+    def get_inputs(self):
+        return (torch.randn(1, 2, 4, 4, 4),)
+
+
 class Conv2dDQSeq(torch.nn.Module):
     def __init__(self, transpose=False):
         super().__init__()
@@ -290,6 +302,41 @@ def test_fp32_conv2d(self) -> None:
             for has_bias in (True, False):
                 self._test(Conv2d(bias=has_bias, transpose=transpose))
 
+    def test_fp32_conv2d_single_element_spatial_params(self) -> None:
+        # ATen broadcasts a single stride/padding/dilation value over every
+        # spatial dim, so a 2d conv can carry length-1 spatial params.
+        for transpose in (True, False):
+            self._test(
+                Conv2d(
+                    kernel_size=(3, 3),
+                    stride=(2,),
+                    padding=(1,),
+                    transpose=transpose,
+                )
+            )
+
+    def test_fp32_conv2d_single_element_dilation(self) -> None:
+        self._test(
+            Conv2d(
+                kernel_size=(3, 3),
+                stride=(1,),
+                padding=(1,),
+                dilation=(2,),
+            )
+        )
+
+    def test_fp32_conv3d_single_element_stride_doesnt_partition(self) -> None:
+        # XNNPACK has no conv3d support, and a length-1 stride must not make a 3d
+        # conv look 1d or 2d to the partitioner.
+        m = Conv3d(stride=(2,))
+        (
+            Tester(m, m.get_inputs())
+            .export()
+            .to_edge_transform_and_lower()
+            .check_count({"torch.ops.higher_order.executorch_call_delegate": 0})
+            .run_method_and_compare_outputs()
+        )
+
     def test_fp32_conv2d_permute(self) -> None:
         for transpose in (True, False):
             for perm_order in list(itertools.permutations([0, 1, 2, 3])):