Cortex-M: build and resolve FVP test runners per target (#20048)

### Summary
The Cortex-M op tests run the .pte on a prebuilt semihosting runner, but
build_test_runner.sh wrote every target to one shared directory and the
ELF was resolved by board (corstone-300) only. A runner built for one
target could therefore be used to run another target's program, silently
producing wrong results.

Build each target's runner into a target-suffixed directory and resolve
the ELF by the test's target. The Arm Serialize/runner_utils ELF lookup
gains an optional, defaulted build_dir_suffix so existing Arm-backend
corstone tests are unaffected; CortexMSerialize passes the target's
canonical cortex-m<variant> string. A target whose runner has not been
built now fails with a clear FileNotFoundError naming the missing
directory instead of running on a mismatched binary.

### Test plan
```
./backends/cortex_m/test/build_test_runner.sh --target=cortex-m0plus
./backends/cortex_m/test/build_test_runner.sh --target=cortex-m7
```

Authored with Claude Code.

cc @digantdesai @freddan80 @per @zingo @oscarandersson8218 @mansnils
@Sebastian-Larsson @robell

Author: rascani

backends/arm/test/runner_utils.py

@@ -892,7 +892,7 @@ def _elf_search_roots() -> list[Path]:
 
 
 def _elf_path_candidates(
-    target_board: str, use_portable_ops: bool = False
+    target_board: str, use_portable_ops: bool = False, build_dir_suffix: str = ""
 ) -> list[Path]:
     if target_board not in VALID_TARGET:
         raise ValueError(f"Unsupported target: {target_board}")
@@ -901,11 +901,14 @@ def _elf_path_candidates(
     if target_board in ("corstone-300", "corstone-320"):
         build_dir = Path(
             "arm_test",
-            f"arm_semihosting_executor_runner_{portable_ops_str}{target_board}",
+            f"arm_semihosting_executor_runner_"
+            f"{portable_ops_str}{target_board}{build_dir_suffix}",
         )
         binary_name = "arm_executor_runner"
     else:
-        build_dir = Path("arm_test", f"arm_executor_runner_{portable_ops_str}vkml")
+        build_dir = Path(
+            "arm_test", f"arm_executor_runner_{portable_ops_str}vkml{build_dir_suffix}"
+        )
         binary_name = "executor_runner"
 
     candidates: list[Path] = []
@@ -950,9 +953,15 @@ def _resolve_existing_elf_path(elf_candidates: Iterable[Path]) -> Path:
     )
 
 
-def get_elf_path(target_board: str, use_portable_ops: bool = False) -> str:
+def get_elf_path(
+    target_board: str, use_portable_ops: bool = False, build_dir_suffix: str = ""
+) -> str:
     elf_path = _resolve_existing_elf_path(
-        _elf_path_candidates(target_board, use_portable_ops=use_portable_ops)
+        _elf_path_candidates(
+            target_board,
+            use_portable_ops=use_portable_ops,
+            build_dir_suffix=build_dir_suffix,
+        )
     )
     return str(elf_path)
 

backends/arm/test/tester/serialize.py

@@ -34,20 +34,25 @@ def __init__(
         module: Optional[torch.nn.Module],
         use_portable_ops: bool = False,
         timeout: int = 120,
+        build_dir_suffix: str = "",
     ):
         """
         Args:
             compile_spec: CompileSpecs to be used for serialization.
             module: Original Module to be used for serialization. Optional - can be used for reference output generation.
             portable_ops: If True tests with compiled in portable ops, default is to test without this to get error if not fully delegated
             timeout: Timeout for fvp. Default is 120 seconds.
+            build_dir_suffix: Suffix appended to the executor-runner build dir
+                name when resolving the ELF, letting callers select a runner
+                built for a specific target (e.g. a Cortex-M variant).
         """
         super().__init__()
         self.module = module
         self.timeout = timeout
         self.executorch_program_manager: ExecutorchProgramManager | None
         self.compile_spec = compile_spec
         self.use_portable_ops = use_portable_ops
+        self.build_dir_suffix = build_dir_suffix
 
     def run(self, artifact: ExecutorchProgramManager, inputs=None) -> None:
         super().run(artifact, inputs)
@@ -62,7 +67,9 @@ def run_artifact(self, inputs):
         inputs_flattened, _ = tree_flatten(inputs)
         intermediate_path = self.compile_spec._get_intermediate_path()
         target_board = get_target_board(self.compile_spec)
-        elf_path = get_elf_path(target_board, self.use_portable_ops)
+        elf_path = get_elf_path(
+            target_board, self.use_portable_ops, build_dir_suffix=self.build_dir_suffix
+        )
 
         if not os.path.exists(elf_path):
             raise FileNotFoundError(

backends/cortex_m/target_config.py

@@ -78,6 +78,12 @@ def __post_init__(self) -> None:
                 f"{self.cpu.name}; supported: {allowed}"
             )
 
+    @property
+    def target_string(self) -> str:
+        """Canonical ``cortex-m<variant>`` string; inverse of
+        ``from_target_string``."""
+        return "cortex-m" + self.cpu.name[1:].lower()
+
     @property
     def backend(self) -> cmsis_nn.Backend:
         if self.isa is not None:
@@ -105,6 +111,6 @@ def from_target_string(cls, target: str) -> CortexMTargetConfig:
         except KeyError as e:
             raise ValueError(
                 f"Unsupported Cortex-M target string: {target!r}. "
-                f"Supported: {sorted('cortex-m' + m.name[1:].lower() for m in CortexM)}"
+                f"Supported: {sorted(cls(cpu=m).target_string for m in CortexM)}"
             ) from e
         return cls(cpu=cpu)

backends/cortex_m/test/build_test_runner.sh

@@ -33,7 +33,7 @@ ${build_executorch} --devtools --target_cpu="${target_cpu}" --cmake-args="-DCORT
 # Build executor runner with selected aten ops and semi hosting
 build_dir="${et_root_dir}/arm_test"
 build_executor_runner="${et_root_dir}/backends/arm/scripts/build_executor_runner.sh"
-build_root_test_dir="${et_root_dir}/arm_test/arm_semihosting_executor_runner_corstone-300"
+build_root_test_dir="${et_root_dir}/arm_test/arm_semihosting_executor_runner_corstone-300_${target}"
 
 select_ops_list="\
 aten::add.out,\

backends/cortex_m/test/tester.py

@@ -69,16 +69,22 @@ def __init__(self, target_config: Optional[CortexMTargetConfig] = None):
 
 
 class CortexMSerialize(Serialize):
-    def __init__(self):
+    def __init__(self, target_config: Optional[CortexMTargetConfig] = None):
+        target_config = target_config or CortexMTargetConfig(cpu=CortexM.M55)
         compile_spec = get_u55_compile_spec()
-        super().__init__(compile_spec, 1024)
+        # Select the runner built for this target (build_test_runner.sh writes
+        # one runner per target into a target-suffixed directory).
+        super().__init__(
+            compile_spec,
+            None,
+            build_dir_suffix=f"_{target_config.target_string}",
+        )
 
 
 cortex_m_stage_classes = {
     StageType.EXPORT: Export,
     StageType.QUANTIZE: CortexMQuantize,
     StageType.RUN_PASSES: CortexMRunPasses,
-    StageType.SERIALIZE: Serialize,
     StageType.TO_EDGE: CortexMToEdge,
     StageType.TO_EXECUTORCH: ToExecutorch,
     StageType.SERIALIZE: CortexMSerialize,
@@ -103,6 +109,9 @@ def __init__(
         stage_classes[StageType.RUN_PASSES] = lambda: CortexMRunPasses(
             target_config=target_config
         )
+        stage_classes[StageType.SERIALIZE] = lambda: CortexMSerialize(
+            target_config=target_config
+        )
         super().__init__(module, resolved_example_inputs, stage_classes)
 
     def test_dialect(

examples/arm/run.sh

@@ -769,16 +769,16 @@ for i in "${!test_model[@]}"; do
         echo "Build for ${target} skip generating a .elf and running it"
         continue
     elif [[ ${target} == cortex-m*  ]]; then
-        # Cortex-M backend uses a shared semihosting executor_runner (built
-        # by build_test_runner.sh) that loads the .bpte at runtime, rather
-        # than per-model runners with the PTE baked in.
+        # Cortex-M backend uses a semihosting executor_runner (built by
+        # build_test_runner.sh, one per target) that loads the .bpte at
+        # runtime, rather than per-model runners with the PTE baked in.
         if [ "$bundleio" != true ]; then
             echo "Error: --target=${target} requires --bundleio (the cortex-m runner loads bundled inputs via semihosting)"
             exit 1
         fi
         set -x
         backends/cortex_m/test/build_test_runner.sh --target="${target}"
-        cortex_m_elf="${et_root_dir}/arm_test/arm_semihosting_executor_runner_corstone-300/arm_executor_runner"
+        cortex_m_elf="${et_root_dir}/arm_test/arm_semihosting_executor_runner_corstone-300_${target}/arm_executor_runner"
         if [ "$build_only" = false ] ; then
             backends/arm/scripts/run_fvp.sh --elf="${cortex_m_elf}" --target="${target}" --bundle="${pte_file}"
         fi