@@ -37,6 +37,7 @@ fbcode_target(_kind = runtime.python_library,
         "decompose_hardswish_pass.py",
         "decompose_mean_pass.py",
         "decompose_sdpa_pass.py",
+        "expand_as_to_expand_pass.py",
         "explicit_layout_pass.py",
         "fuse_conv_padding_pass.py",
         "initialize_scratch_buffers_pass.py",
 
@@ -52,6 +52,7 @@
 from .decompose_hardswish_pass import DecomposeHardswishPass
 from .decompose_mean_pass import DecomposeMeanPass
 from .decompose_sdpa_pass import DecomposeSDPAPass
+from .expand_as_to_expand_pass import ExpandAsToExpandPass
 from .explicit_layout_pass import (
     CortexMCanonicalizeViewCopyPermutePass,
     CortexMReplaceOpsWithChannelsLastVariants,
@@ -195,6 +196,7 @@ class CortexMPassManager(ExportedProgramPassManager):
         ClampHardswishPass,
         DecomposeMeanPass,
         MatmulToBmmPass,
+        ExpandAsToExpandPass,
         DeduplicateGetAttrPass,
     ]
 
 
@@ -0,0 +1,47 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import cast, Dict
+
+import torch
+from executorch.exir.pass_base import ExportPass, NodeMetadata, ProxyValue
+
+from torch._ops import OpOverload
+from torch.fx.node import Argument
+
+
+class ExpandAsToExpandPass(ExportPass):
+    """
+    Rewrites ``aten.expand_as.default`` into ``aten.expand.default`` so it gets
+    the shared-qparams treatment ``SharedQspecQuantizer`` already gives
+    ``expand``. ``expand_as`` only decomposes at ``to_edge``, after
+    quantization, and its second operand is used for its shape alone, so it
+    must not be tied into the shared-qparams cluster.
+
+    This is what the ATen composite itself does -- ``expand_as(self, other)``
+    is ``self.expand_symint(other.sym_sizes())`` -- read off the second
+    operand a dimension at a time. A dynamic dimension cannot be copied
+    across as a value, because the shape entry is a symbol rather than a
+    number; ``call_size_operator_all`` emits the ``sym_size.int`` that reads
+    it off the tensor at run time.
+    """
+
+    def call_operator(
+        self,
+        op: OpOverload,
+        args: tuple[Argument, ...],
+        kwargs: Dict[str, Argument],
+        meta: NodeMetadata,
+    ) -> ProxyValue:
+        if op != torch.ops.aten.expand_as.default:
+            return super().call_operator(op, args, kwargs, meta)
+
+        source = cast(ProxyValue, args[0])
+        other = cast(ProxyValue, args[1])
+        sizes = self.call_size_operator_all(other, meta)
+        return super().call_operator(
+            torch.ops.aten.expand.default, (source, sizes), {}, meta
+        )
@@ -144,6 +144,26 @@ def define_common_targets(is_fbcode = False):
 
 
 
+        python_pytest(
+            name = "test_expand_lowering",
+            srcs = ["test_expand_lowering.py"],
+            compile = "with-source",
+            typing = False,
+            deps = [
+                "//caffe2:torch",
+                "//pytorch/ao:torchao",  # @manual
+                "//executorch/backends/cortex_m:edge_compile_config",
+                "//executorch/backends/cortex_m/ops:ops",
+                "//executorch/backends/cortex_m/passes:cortex_passes",
+                "//executorch/backends/cortex_m/quantizer:quantizer",
+                "//executorch/backends/test/harness:tester",
+                "//executorch/exir:lib",
+                "//executorch/exir/dialects:lib",
+                "fbsource//third-party/pypi/pytest:pytest",
+                ":tester",
+            ],
+        )
+
         python_pytest(
             name = "test_fuse_conv_padding",
             srcs = ["test_fuse_conv_padding.py"],
 
@@ -0,0 +1,151 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import pytest
+import torch
+from executorch.backends.cortex_m.edge_compile_config import (
+    cortex_m_edge_compile_config,
+)
+from executorch.backends.cortex_m.passes.cortex_m_pass_manager import CortexMPassManager
+from executorch.backends.cortex_m.quantizer.quantizer import CortexMQuantizer
+from executorch.backends.cortex_m.test.tester import CortexMTester
+from executorch.backends.test.harness.stages import StageType
+from executorch.exir import to_edge_transform_and_lower
+from executorch.exir.dialects._ops import ops as exir_ops
+from torch.export import Dim, export
+from torchao.quantization.pt2e.quantize_pt2e import convert_pt2e, prepare_pt2e
+
+
+class ExpandBetweenQuantizedOps(torch.nn.Module):
+    def forward(self, x, y, z):
+        return (x * y).expand(4, 8) + z
+
+
+class ExpandAsBetweenQuantizedOps(torch.nn.Module):
+    def forward(self, x, y, z):
+        return (x * y).expand_as(z) + z
+
+
+class ExpandBetweenFloatOps(torch.nn.Module):
+    def forward(self, x, z):
+        return torch.cumsum(torch.cumsum(x, dim=1).expand(4, 8), dim=0)
+
+
+class ExpandAsBetweenFloatOps(torch.nn.Module):
+    def forward(self, x, z):
+        return torch.cumsum(torch.cumsum(x, dim=1).expand_as(z), dim=0)
+
+
+class ExpandAsWithQuantizedShapeOperand(torch.nn.Module):
+    def forward(self, x, y, z):
+        other = z + z
+        return (x * y).expand_as(other) + other
+
+
+def quantize(model, inputs, dynamic_shapes=None):
+    captured = export(model, inputs, dynamic_shapes=dynamic_shapes).module()
+    prepared = prepare_pt2e(captured, CortexMQuantizer())
+    prepared(*inputs)
+    return convert_pt2e(prepared)
+
+
+def is_qdq(node) -> bool:
+    return "quantize_per_tensor" in str(node.target)
+
+
+def single_expand(gm):
+    (expand,) = gm.graph.find_nodes(
+        op="call_function", target=torch.ops.aten.expand.default
+    )
+    return expand
+
+
+@pytest.mark.parametrize(
+    "model,inputs",
+    [
+        (
+            ExpandBetweenQuantizedOps(),
+            (torch.randn(1, 8), torch.randn(1, 8), torch.randn(4, 8)),
+        ),
+        (
+            ExpandBetweenQuantizedOps(),
+            (torch.randn(8), torch.randn(8), torch.randn(4, 8)),
+        ),
+        (
+            ExpandAsBetweenQuantizedOps(),
+            (torch.randn(1, 8), torch.randn(1, 8), torch.randn(4, 8)),
+        ),
+        (
+            ExpandAsBetweenQuantizedOps(),
+            (torch.randn(8), torch.randn(8), torch.randn(4, 8)),
+        ),
+    ],
+    ids=["expand", "expand_rank_change", "expand_as", "expand_as_rank_change"],
+)
+def test_expand_with_quantized_neighbors_runs_on_int8(model, inputs):
+    tester = CortexMTester(model.eval(), inputs)
+    tester.quantize().export().to_edge().run_passes()
+    program = tester.get_artifact(StageType.RUN_PASSES).exported_program()
+
+    (expand,) = program.graph.find_nodes(
+        op="call_function", target=exir_ops.edge.aten.expand_copy.default
+    )
+    assert expand.args[0].meta["val"].dtype == torch.int8
+    tester.run_method_and_compare_outputs(inputs=inputs, qtol=1)
+
+
+@pytest.mark.parametrize(
+    "model", [ExpandBetweenFloatOps(), ExpandAsBetweenFloatOps()], ids=["expand", "expand_as"]
+)
+def test_expand_between_float_ops_stays_float(model):
+    expand = single_expand(quantize(model, (torch.randn(1, 8), torch.randn(4, 8))))
+
+    assert not is_qdq(expand.args[0])
+    assert not any(is_qdq(user) for user in expand.users)
+
+
+def test_expand_as_does_not_share_qparams_with_its_shape_operand():
+    inputs = (torch.randn(1, 8), torch.randn(1, 8), 10 * torch.randn(4, 8))
+    expand = single_expand(quantize(ExpandAsWithQuantizedShapeOperand(), inputs))
+
+    dequantize = expand.args[0]
+    assert is_qdq(dequantize)
+    assert dequantize.args[0].args[0].target == torch.ops.aten.mul.Tensor
+    (quantize_after_expand,) = expand.users
+    (add,) = [
+        user
+        for dq in quantize_after_expand.users
+        for user in dq.users
+        if user.target == torch.ops.aten.add.Tensor
+    ]
+    other_dequantize = add.args[1]
+    assert is_qdq(other_dequantize)
+    assert dequantize.args[1] != other_dequantize.args[1]
+    assert all(isinstance(size, int) for size in expand.args[1])
+
+
+def test_expand_as_with_dynamic_shape_reads_the_size_at_runtime():
+    inputs = (torch.randn(1, 8), torch.randn(1, 8), torch.randn(4, 8))
+    dynamic_shapes = ({}, {}, {0: Dim("B")})
+    quantized = quantize(ExpandAsBetweenQuantizedOps(), inputs, dynamic_shapes)
+    expand = single_expand(quantized)
+
+    assert any(
+        isinstance(size, torch.fx.Node) and size.target == torch.ops.aten.sym_size.int
+        for size in expand.args[1]
+    )
+    assert is_qdq(expand.args[0])
+    assert any(is_qdq(user) for user in expand.users)
+
+    edge = to_edge_transform_and_lower(
+        export(quantized, inputs, dynamic_shapes=dynamic_shapes),
+        compile_config=cortex_m_edge_compile_config(),
+        transform_passes=CortexMPassManager(),
+    )
+    (expand_copy,) = edge.exported_program().graph.find_nodes(
+        op="call_function", target=exir_ops.edge.aten.expand_copy.default
+    )
+    assert expand_copy.args[0].meta["val"].dtype == torch.int8