Cortex-M backend: address #19470 review feedback

Aligns CortexMTargetConfig with the design Erik proposes in #19505
while keeping the wider plumbing in place. The earlier
CortexMCompileConfig is renamed to CortexMTargetConfig (and its file
moved to target_config.py) to disambiguate from EdgeCompileConfig —
this dataclass models a compilation *target*, not a step in the
compile pipeline.

Adopted from Erik's feedback:

* CortexM enum replaces the Cpu/Isa Literals — typo-safe and
  IDE-friendly.
* `.backend` property returns `cmsis_nn.Backend` directly, resolved
  via `cmsis_nn.resolve_backend(cmsis_nn.CortexM.<X>)`. The
  hand-rolled `_CPU_DEFAULT_ISA` dict is gone — cmsis_nn is the
  single source of truth for the CPU → backend mapping.
* CortexMPass abstract base class added; CortexMPassManager.transform()
  uses signature inspection to inject both `exported_program` and
  `target_config` into passes that declare them (mirroring Erik's
  proposal). The pass manager also gains stricter validation — the
  exported_program must be a real ExportedProgram and the pass list
  must contain classes, not instances — failing fast instead of
  producing opaque errors deep in _transform.
* cmsis_nn is now a hard dependency for the cortex_m tests: the
  top-level `import cmsis_nn` in test_target_config.py replaces the
  previous skipif-on-find_spec dance, addressing Erik's concern that
  skipping tests on missing deps can mask regressions.
* `+int8` dropped from cortex-m target strings — quantization is a
  result of the export flow, not a CPU attribute. TARGETS, help text,
  from_target_string, CI script and README aligned.
* Logging in `_to_edge_cortex_m` and the --delegate-ignored warning
  switched to f-strings.
* `__init__` docstring on CortexMPassManager documents the
  exported_program / passes / target_config defaults (including the
  M55+MVE fallback that matches pre-config behaviour).
* `import-not-found` removed from the cmsis_nn type-ignore — only
  `import-untyped` actually fires, and if cmsis_nn ever ships stubs
  the unused ignore will become a tripwire.

Kept the optional `isa` override field for the optional-extension
cases (M55 without MVE, M33 without DSP, etc.) — different from
Erik's enum-only design, but the override remains useful for cores
where ISA extensions are optional. A `_SUPPORTED_BACKENDS` table
encodes the per-CPU architectural capability set so overrides
validate at construction; forcing MVE on an M0 raises ValueError
with the actual supported list. The SCALAR ⊂ DSP ⊂ MVE supersession
reflects that an MVE-capable core also runs DSP and scalar code.

Defers Erik's `ANY` proposal. In #19505 ANY falls back to MVE, but an
honest "any cortex-m" choice would have to do worst-case scratch
buffer planning across the ISA classes (which may not be MVE).
Deferring until the scratch-buffer side lands and we can implement
the worst-case analysis properly.

Authored with Claude.

Author: rascani

.ci/scripts/test_cortex_m_e2e.sh

@@ -17,9 +17,9 @@ MODEL=$1
 script_dir=$(realpath "$(dirname "${BASH_SOURCE[0]}")")
 et_root_dir=$(realpath "${script_dir}/../..")
 
-# Quantization is the default for the cortex-m55+int8 target; run.sh's
+# Quantization is the default for the cortex-m55 target; run.sh's
 # arg parser only recognizes --no_quantize, so we omit any explicit flag.
 bash "${et_root_dir}/examples/arm/run.sh" \
     --model_name="${MODEL}" \
-    --target=cortex-m55+int8 \
+    --target=cortex-m55 \
     --bundleio

backends/arm/scripts/aot_arm_compiler.py

@@ -33,13 +33,13 @@
 from executorch.backends.arm.util._factory import create_partitioner, create_quantizer
 
 from executorch.backends.arm.vgf import VgfCompileSpec
-from executorch.backends.cortex_m.compile_config import CortexMCompileConfig
 from executorch.backends.cortex_m.passes.cortex_m_pass_manager import CortexMPassManager
 
 from executorch.backends.cortex_m.passes.replace_quant_nodes_pass import (
     ReplaceQuantNodesPass,
 )
 from executorch.backends.cortex_m.quantizer.quantizer import CortexMQuantizer
+from executorch.backends.cortex_m.target_config import CortexMTargetConfig
 from executorch.devtools import BundledProgram, generate_etrecord
 from executorch.devtools.backend_debug import get_delegation_info
 from executorch.devtools.bundled_program.config import MethodTestCase, MethodTestSuite
@@ -466,17 +466,16 @@ def forward(self, x):
     "TOSA-1.0+INT",
     "TOSA-1.0+FP",
     "TOSA-1.0+INT+int16",
-    "cortex-m0+int8",
-    "cortex-m0plus+int8",
-    "cortex-m3+int8",
-    "cortex-m4+int8",
-    "cortex-m7+int8",
-    "cortex-m23+int8",
-    "cortex-m33+int8",
-    "cortex-m35p+int8",
-    "cortex-m52+int8",
-    "cortex-m55+int8",
-    "cortex-m85+int8",
+    "cortex-m0",
+    "cortex-m0plus",
+    "cortex-m3",
+    "cortex-m4",
+    "cortex-m7",
+    "cortex-m23",
+    "cortex-m33",
+    "cortex-m35p",
+    "cortex-m55",
+    "cortex-m85",
 ]
 
 
@@ -577,7 +576,7 @@ def _get_args():
         required=False,
         default="ethos-u55-128",
         choices=TARGETS,
-        help=f"Target backend. For delegated models: Ethos-U/VGF/TOSA variants. For non-delegated: cortex-m<variant>+int8 (CMSIS-NN portable kernels). Valid targets: {TARGETS}",
+        help=f"Target backend. For delegated models: Ethos-U/VGF/TOSA variants. For non-delegated: cortex-m<variant> (CMSIS-NN portable kernels). Valid targets: {TARGETS}",
     )
     # TODO: Remove --evaluate and --evaluate_config completely after a suitable time.
     # They are deprecated and no longer functional in this script.
@@ -871,13 +870,12 @@ def _to_edge_cortex_m(
     model: GraphModule,
     example_inputs: Tuple[torch.Tensor],
     calibration_samples: Optional[List[Tuple[torch.Tensor, ...]]],
-    config: CortexMCompileConfig,
+    target_config: CortexMTargetConfig,
 ):
     """Cortex-M/CMSIS-NN compilation path with no delegation."""
     logging.info(
-        "Using Cortex-M/CMSIS-NN compilation path for cpu=%s isa=%s",
-        config.cpu,
-        config.isa,
+        f"Using Cortex-M/CMSIS-NN compilation path for cpu={target_config.cpu.name} "
+        f"backend={target_config.backend.name}"
     )
 
     def _to_channels_last(x):
@@ -931,7 +929,9 @@ def _to_channels_last(x):
         ),
     )
 
-    pass_manager = CortexMPassManager(edge.exported_program(), config=config)
+    pass_manager = CortexMPassManager(
+        edge.exported_program(), target_config=target_config
+    )
     edge._edge_programs["forward"] = pass_manager.transform()
 
     return model_quant, edge
@@ -1025,12 +1025,11 @@ def main() -> None:  # noqa: C901
 
     if args.target.startswith("cortex-m"):
         # Cortex-M path: CMSIS-NN portable kernels, no delegation
-        cortex_m_config = CortexMCompileConfig.from_target_string(args.target)
+        target_config = CortexMTargetConfig.from_target_string(args.target)
         if args.delegate:
             logging.warning(
-                "--delegate is ignored for target %r "
-                "(this target does not use delegated ops).",
-                args.target,
+                f"--delegate is ignored for target {args.target!r} "
+                "(this target does not use delegated ops)."
             )
             args.delegate = False
         model_quant, edge = _to_edge_cortex_m(
@@ -1039,7 +1038,7 @@ def main() -> None:  # noqa: C901
             model,
             example_inputs,
             calibration_samples,
-            cortex_m_config,
+            target_config,
         )
     elif args.delegate:
         # As we can target multiple output encodings, one must

backends/cortex_m/compile_config.py

@@ -36,6 +36,7 @@ def _ensure_cortex_m_dependencies() -> None:
 from .activation_fusion_pass import ActivationFusionPass  # noqa
 from .clamp_hardswish_pass import ClampHardswishPass  # noqa
 from .convert_to_cortex_m_pass import ConvertToCortexMPass  # noqa
+from .cortex_m_pass import CortexMPass  # noqa
 from .decompose_hardswish_pass import DecomposeHardswishPass  # noqa
 from .decompose_mean_pass import DecomposeMeanPass  # noqa
 from .quantized_clamp_activation_pass import QuantizedClampActivationPass  # noqa

backends/cortex_m/passes/__init__.py

@@ -0,0 +1,35 @@
+# 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 executorch.backends.cortex_m.target_config import CortexMTargetConfig
+from executorch.exir.pass_base import ExportPass
+from torch.export import ExportedProgram
+
+
+class CortexMPass(ExportPass):
+    """Base class for passes that need the Cortex-M target config.
+
+    Passes that subclass this declare `exported_program` and `target_config`
+    in their `__init__`; `CortexMPassManager.transform()` injects both
+    automatically when running the pass list.
+    """
+
+    def __init__(
+        self,
+        exported_program: ExportedProgram,
+        target_config: CortexMTargetConfig,
+    ) -> None:
+        super().__init__()
+        self._exported_program = exported_program
+        self._target_config = target_config
+
+    @property
+    def exported_program(self) -> ExportedProgram:
+        return self._exported_program
+
+    @property
+    def target_config(self) -> CortexMTargetConfig:
+        return self._target_config

backends/cortex_m/passes/cortex_m_pass.py

@@ -5,13 +5,13 @@
 
 
 import inspect
-from typing import Callable, cast, Optional, Type
+from typing import Any, Optional, Type
 
 from executorch.backends.arm._passes import (
     FoldAndAnnotateQParamsPass,
     ScalarsToAttributePass,
 )
-from executorch.backends.cortex_m.compile_config import CortexMCompileConfig
+from executorch.backends.cortex_m.target_config import CortexM, CortexMTargetConfig
 from executorch.backends.transforms.remove_getitem_op import RemoveGetItemPass
 from executorch.backends.transforms.replace_scalar_with_tensor import (
     ReplaceScalarWithTensorArgPass,
@@ -20,9 +20,6 @@
 from executorch.exir.pass_manager import PassManager
 from executorch.exir.program._program import _transform, lift_constant_tensor_pass
 from torch.export import ExportedProgram
-from torch.fx.passes.infra.pass_base import PassResult
-
-from torch.nn import Module
 
 from .activation_fusion_pass import ActivationFusionPass
 from .clamp_hardswish_pass import ClampHardswishPass
@@ -59,17 +56,32 @@ class CortexMPassManager(PassManager):
 
     def __init__(
         self,
-        exported_program,
+        exported_program: ExportedProgram | None,
         passes: Optional[list[PassClass]] = None,
-        config: Optional[CortexMCompileConfig] = None,
+        target_config: Optional[CortexMTargetConfig] = None,
     ) -> None:
+        """Initialize the Cortex-M pass manager.
+
+        Args:
+            exported_program: The exported program to transform. Required
+                before calling ``transform()``; may be ``None`` for callers
+                that only use ``transform_for_annotation()``.
+            passes: Optional override of the pass list. Defaults to
+                ``CortexMPassManager.pass_list``.
+            target_config: Compilation target for passes that need it.
+                Defaults to ``CortexMTargetConfig(cpu=CortexM.M55)``, which
+                resolves through cmsis_nn to the MVE backend — matching the
+                pre-config historical behaviour.
+        """
         super().__init__(passes=[])
         self.exported_program = exported_program
         # PassManager.passes is typed as callables; this manager stores pass classes which are initialized at transform time with the exported_program.
         self.passes: list[PassClass] = (  # type: ignore[assignment]
             passes if passes is not None else self.pass_list  # type: ignore[assignment]
         )
-        self.config: CortexMCompileConfig = config or CortexMCompileConfig()
+        self.target_config: CortexMTargetConfig = target_config or CortexMTargetConfig(
+            cpu=CortexM.M55
+        )
 
     def transform_for_annotation(self, model):
         passes = self.pass_list_transform_for_annotation
@@ -78,18 +90,31 @@ def transform_for_annotation(self, model):
         return model
 
     def transform(self) -> ExportedProgram:
-        ep = self.exported_program
+        exported_program = self.exported_program
+        if not isinstance(exported_program, ExportedProgram):
+            raise ValueError(
+                f"{type(self).__name__}.transform() needs a real ExportedProgram, "
+                f"got {exported_program!r}"
+            )
+
         for pass_cls in self.passes:
+            if not isinstance(pass_cls, type):
+                raise ValueError(
+                    f"{type(self).__name__} expects pass classes, not instances; "
+                    f"got {pass_cls!r}"
+                )
+
             signature = inspect.signature(pass_cls)
+            kwargs: dict[str, Any] = {}
             if "exported_program" in signature.parameters:
-                ep_pass_ctor = cast(Callable[[ExportedProgram], ExportPass], pass_cls)
-                transform_pass = ep_pass_ctor(ep)
-            else:
-                transform_pass = pass_cls()
-            pass_callable = cast(Callable[[Module], PassResult], transform_pass)
-            ep = _transform(ep, pass_callable)
+                kwargs["exported_program"] = exported_program
+            if "target_config" in signature.parameters:
+                kwargs["target_config"] = self.target_config
+
+            transform_pass = pass_cls(**kwargs)
+            exported_program = _transform(exported_program, transform_pass)
 
         # All constant tensors should be lifted to buffers at this point, re-run
-        # lift_constant_tensor_pass in case new ones have been introduced by the passes above.
-        ep = lift_constant_tensor_pass(ep)
-        return ep
+        # lift_constant_tensor_pass in case new ones have been introduced.
+        exported_program = lift_constant_tensor_pass(exported_program)
+        return exported_program