Merge branch 'main' into mlx-add-bitwise-or

Author: devin-lai

.lintrunner.toml

@@ -109,16 +109,106 @@ is_formatter = true
 [[linter]]
 code = 'CPPCHECK'
 include_patterns = [
-    'backends/arm/**/*.cpp',
-    'backends/arm/**/*.h',
-    'backends/arm/**/*.hpp',
-    'backends/cortex_m/**/*.cpp',
-    'backends/cortex_m/**/*.h',
-    'examples/arm/**/*.cpp',
-    'examples/arm/**/*.h',
-    'examples/arm/**/*.hpp',
+    '**/*.cpp',
+    '**/*.h',
+    '**/*.hpp',
 ]
 exclude_patterns = [
+    # Third-party and vendored code.
+    'third-party/**',
+    'third_party/**',
+    '**/third-party/**',
+    '**/third_party/**',
+
+    # Mirrored sources under src/ (Python package layout). Prefer linting canonical paths.
+    'src/executorch/**',
+    # PyTorch compatibility code kept in sync with upstream.
+    'runtime/core/portable_type/c10/**',
+
+    # Generated sources, templates, and codegen tooling to onboard separately.
+    'codegen/templates/**',
+    'codegen/tools/selective_build.cpp',
+    'exir/_serialize/**',
+
+    # Backend-owned code to onboard separately.
+    'backends/aoti/**',
+    'backends/apple/**',
+    'backends/cadence/**',
+    'backends/cuda/**',
+    'backends/mediatek/**',
+    'backends/mlx/**',
+    'backends/nxp/**',
+    'backends/openvino/**',
+    'backends/qualcomm/**',
+    'backends/samsung/**',
+    'backends/test/**',
+    'backends/vulkan/**',
+    'backends/webgpu/**',
+    'backends/xnnpack/**',
+
+    # Backend-owned examples to onboard with those backends.
+    'examples/demo-apps/**',
+    'examples/mediatek/**',
+    'examples/nxp/**',
+    'examples/qualcomm/**',
+    'examples/samsung/**',
+
+    # Other examples to onboard separately.
+    'examples/devtools/**',
+    'examples/llm_manual/**',
+    'examples/models/**',
+    'examples/portable/**',
+    'examples/raspberry_pi/**',
+
+    # EXIR and devtools areas to onboard separately.
+    'devtools/bundled_program/**',
+    'devtools/etdump/**',
+    'exir/backend/test/**',
+    'exir/tests/**',
+    'exir/verification/**',
+
+    # Extension areas to onboard incrementally.
+    'extension/android/**',
+    'extension/apple/**',
+    'extension/asr/runner/transducer_runner.h',
+    'extension/aten_util/**',
+    'extension/benchmark/apple/**',
+    'extension/data_loader/**',
+    'extension/evalue_util/**',
+    'extension/flat_tensor/**',
+    'extension/kernel_util/make_boxed_from_unboxed_functor.h',
+    'extension/kernel_util/test/**',
+    'extension/llm/**',
+    'extension/memory_allocator/**',
+    'extension/module/**',
+    'extension/named_data_map/**',
+    'extension/pybindings/**',
+    'extension/pytree/**',
+    'extension/runner_util/**',
+    'extension/tensor/**',
+    'extension/testing_util/**',
+    'extension/threadpool/**',
+    'extension/training/**',
+    'extension/wasm/**',
+
+    # Kernel areas to onboard separately.
+    'kernels/aten/**',
+    'kernels/optimized/**',
+    'kernels/portable/**',
+    'kernels/prim_ops/**',
+    'kernels/quantized/**',
+    'kernels/test/**',
+
+    # Runtime areas to onboard incrementally.
+    'runtime/backend/**',
+    'runtime/core/**',
+    'runtime/executor/**',
+    'runtime/kernel/**',
+    'runtime/platform/**',
+
+    # Top-level test and platform integration areas.
+    'test/**',
+    'zephyr/**',
 ]
 command = [
     'python',

backends/apple/coreml/CMakeLists.txt

@@ -230,12 +230,6 @@ if(APPLE)
 
   executorch_target_link_options_shared_lib(coremldelegate)
 
-  if(EXECUTORCH_COREML_BUILD_EXECUTOR_RUNNER)
-    target_link_libraries(
-      coremldelegate PRIVATE portable_ops_lib portable_kernels
-    )
-  endif()
-
   target_compile_options(
     coremldelegate PRIVATE -fobjc-arc -fno-exceptions -x objective-c++
                            -Wno-null-character -Wno-receiver-expr

backends/arm/_passes/__init__.py

@@ -42,6 +42,7 @@
 from .decompose_cumsum_pass import DecomposeCumsumPass  # noqa
 from .decompose_div_pass import DecomposeDivPass  # noqa
 from .decompose_div_tensor_mode import DecomposeDivTensorModePass  # noqa
+from .decompose_dynamic_full_pass import DecomposeDynamicFullPass  # noqa
 from .decompose_einsum_pass import DecomposeEinsumPass  # noqa
 from .decompose_elu_pass import ConvertEluFamilyToEluPass, DecomposeEluPass  # noqa
 from .decompose_embedding_pass import DecomposeEmbeddingPass  # noqa  # noqa

backends/arm/_passes/arm_pass_manager.py

@@ -49,6 +49,7 @@
     DecomposeCumsumPass,
     DecomposeDivPass,
     DecomposeDivTensorModePass,
+    DecomposeDynamicFullPass,
     DecomposeEinsumPass,
     DecomposeEluPass,
     DecomposeEmbeddingPass,
@@ -150,10 +151,7 @@
 )
 from executorch.backends.arm._passes.arm_pass import ArmPass
 from executorch.backends.arm.common.arm_compile_spec import ArmCompileSpec
-from executorch.backends.arm.common.pipeline_config import (
-    ArmPassPipelineConfig,
-    SoftmaxDecompositionConfig,
-)
+from executorch.backends.arm.common.pipeline_config import SoftmaxDecompositionConfig
 from executorch.backends.arm.tosa.specification import (
     tosa_spec_in_set,
     TosaLoweringContext,
@@ -221,16 +219,13 @@ def __init__(self, compile_spec: ArmCompileSpec) -> None:
         super().__init__()
         self.configure_skip_passes()
 
-    def configure_skip_passes(
-        self,
-        override_config: ArmPassPipelineConfig | None = None,
-    ) -> tuple[type, ...]:
+    def configure_skip_passes(self) -> tuple[type, ...]:
         """Configures the pass manager to skip certain passes based on the
         ArmPassPipelineConfig class found in the compile spec.
         """
         skip_set: set[type] = set()
 
-        config = override_config or self.compile_spec._get_pass_pipeline_config()
+        config = self.compile_spec._get_pass_pipeline_config()
         logger.debug(f"Skip Config: {config}")
 
         match config.softmax:
@@ -502,6 +497,7 @@ def _tosa_pipeline(
                 ConvertMinMaxPass(),
                 DecomposeAnyPass(),
                 DecorateFp32toInt32CastingPass(),
+                DecomposeDynamicFullPass(),
                 ConvertExpandCopyToRepeatPass(),
                 UnsqueezeBeforeRepeatPass(),
                 DecomposeCumsumPass(exported_program),
@@ -588,6 +584,7 @@ def transform_for_annotation_pipeline(self, graph_module: GraphModule):
                     DecomposeIndexCopyPass(tfa_pass=True),
                     DecomposeSelectScatterPass(tfa_pass=True),
                     DecomposeSliceScatterPass(tfa_pass=True),
+                    DecomposeDynamicFullPass(tfa_pass=True),
                     ConvertInt64ConstOpsToInt32Pass(tfa_pass=True),
                     ConvertInt64OutputOpsToInt32Pass(tfa_pass=True),
                     InsertInt32CastsAfterInt64PlaceholdersPass(tfa_pass=True),
@@ -649,9 +646,14 @@ def transform_for_annotation_pipeline(self, graph_module: GraphModule):
             )
 
             # Postprocessing passes
+            quant_inf_cfg = self.compile_spec._get_pass_pipeline_config().quantize_inf
             self.add_passes(
                 [
-                    ReplaceInfAndLimitValuesPass(tfa_pass=True),
+                    ReplaceInfAndLimitValuesPass(
+                        quant_inf_cfg.neg_inf,
+                        quant_inf_cfg.pos_inf,
+                        tfa_pass=True,
+                    ),
                     DecomposeMaskedFillPass(tfa_pass=True),
                     DeduplicateGetAttrPass(tfa_pass=True),
                 ]

backends/arm/_passes/decompose_dynamic_full_pass.py

@@ -0,0 +1,55 @@
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# 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 Any, Set, Type
+
+import torch
+from executorch.backends.arm._passes.arm_pass import ArmPass
+from executorch.backends.arm._passes.unsqueeze_before_repeat_pass import (
+    UnsqueezeBeforeRepeatPass,
+)
+from executorch.exir.dialects._ops import ops as exir_ops
+from executorch.exir.pass_base import ExportPass
+
+
+class DecomposeDynamicFullPass(ArmPass):
+    """Rewrite dynamic-shape `full` into scalar `full` plus `repeat`."""
+
+    _passes_required_after: Set[Type[ExportPass]] = {UnsqueezeBeforeRepeatPass}
+
+    full_targets = {
+        torch.ops.aten.full.default,
+        exir_ops.edge.aten.full.default,
+    }
+    repeat = exir_ops.edge.aten.repeat.default
+
+    @staticmethod
+    def _has_symbolic_extent(size: Any) -> bool:
+        return isinstance(size, (list, tuple)) and any(
+            not isinstance(dim, int) for dim in size
+        )
+
+    def call_operator(self, op, args, kwargs, meta, updated=False):
+        if op not in self.full_targets:
+            return super().call_operator(op, args, kwargs, meta, updated)
+
+        size, fill_value = args[:2]
+        if not self._has_symbolic_extent(size):
+            return super().call_operator(op, args, kwargs, meta, updated)
+
+        scalar_full = super().call_operator(
+            op=op,
+            args=((1,), fill_value),
+            kwargs=kwargs,
+            meta=meta,
+            updated=True,
+        )
+        return super().call_operator(
+            op=self.repeat,
+            args=(scalar_full, size),
+            kwargs={},
+            meta=meta,
+            updated=True,
+        )

backends/arm/_passes/insert_const_shapes.py

@@ -40,6 +40,13 @@ def _is_shape_arg(arg: Any) -> bool:
             and all(isinstance(x, int) for x in arg)
         )
 
+    def call(self, graph_module):
+        self._const_shape_cache.clear()
+        try:
+            return super().call(graph_module)
+        finally:
+            self._const_shape_cache.clear()
+
     def call_operator(self, op, args, kwargs, meta, updated: Optional[bool] = False):
         if op not in self.target_ops:
             return super().call_operator(op, args, kwargs, meta, updated)

backends/arm/_passes/replace_inf_and_limit_values_pass.py

@@ -16,12 +16,22 @@
 
 class ReplaceInfAndLimitValuesPass(ArmPass):
     """Rewrites +inf/-inf and floating-point limit values (e.g.,
-    torch.finfo(...).min/max) to quantization-friendly values (±255 by default),
+    torch.finfo(...).min/max) to configured quantization-friendly values,
     improving quantizer stability (notably for attention mask paths).
     """
 
     _passes_required_after: Set[Type[ExportPass]] = set()
 
+    def __init__(
+        self,
+        neg_inf: float,
+        pos_inf: float,
+        tfa_pass: bool = False,
+    ):
+        super().__init__(tfa_pass=tfa_pass)
+        self.neg_inf = neg_inf
+        self.pos_inf = pos_inf
+
     def _allowed_to_transform_named_buffer(self, buf_name, graph_module) -> bool:
         attr_nodes = [
             node
@@ -51,19 +61,19 @@ def call(self, graph_module: torch.fx.GraphModule):
                 continue
 
             modified = True
-            # 255 here is mainly for attention_mask in Llama for reasonable quant scale
-            t = torch.nan_to_num(tensor, posinf=255, neginf=-255)
+
+            t = torch.nan_to_num(tensor, posinf=self.pos_inf, neginf=self.neg_inf)
             setattr(graph_module, buf_name, t)
 
         for node in graph_module.graph.nodes:
             arg_list = list(node.args)
             for index, arg in enumerate(arg_list):
                 if arg == float("-inf") or arg == torch.finfo(torch.float32).min:
                     modified = True
-                    arg_list[index] = -255.0
+                    arg_list[index] = self.neg_inf
                 elif arg == float("inf") or arg == torch.finfo(torch.float32).max:
                     modified = True
-                    arg_list[index] = +255.0
+                    arg_list[index] = self.pos_inf
             node.args = tuple(arg_list)
 
         if modified: